catniff 0.6.0 → 0.6.1

package/dist/core.d.ts

@@ -47,12 +47,15 @@ export declare class Tensor {
     static normalizeDims(dims: number[], numDims: number): number[];
     isContiguous(): boolean;
     contiguous(): Tensor;
+    view(newShape: readonly number[]): Tensor;
     reshape(newShape: readonly number[]): Tensor;
     transpose(dim1: number, dim2: number): Tensor;
     swapaxes: (dim1: number, dim2: number) => Tensor;
     swapdims: (dim1: number, dim2: number) => Tensor;
     t(): Tensor;
     permute(dims: number[]): Tensor;
+    indexWithArray(indices: number[]): Tensor;
+    index(indices: Tensor | TensorValue): Tensor;
     slice(ranges: number[][]): Tensor;
     squeeze(dims?: number[] | number): Tensor;
     unsqueeze(dim: number): Tensor;

package/dist/core.js

@@ -103,7 +103,7 @@ class Tensor {
                 newShape[index] = shapeA[index];
             }
             else {
-                throw new Error(`Cannot broadcast shapes: ${shapeA} and ${shapeB}`);
+                throw new Error(`Can not broadcast shapes: ${shapeA} and ${shapeB}`);
             }
         }
         return newShape;
@@ -325,13 +325,37 @@ class Tensor {
         }
         return out;
     }
+    view(newShape) {
+        // Verify shape size
+        const originalSize = this.numel;
+        const outputSize = Tensor.shapeToSize(newShape);
+        if (originalSize !== outputSize) {
+            throw new Error("Can not create view: incompatible sizes");
+        }
+        // Verify compatibility (only contiguity for now)
+        if (!this.isContiguous()) {
+            throw new Error("Can not create view: incompatible metadata");
+        }
+        const outputStrides = Tensor.getStrides(newShape);
+        const out = new Tensor(this.value, { shape: newShape, strides: outputStrides, numel: outputSize });
+        // Gradient reshaped and flow back to the original tensor
+        if (this.requiresGrad) {
+            out.requiresGrad = true;
+            out.children.push(this);
+            out.gradFn = () => {
+                Tensor.addGrad(this, out.grad.reshape(this.shape));
+            };
+        }
+        return out;
+    }
     reshape(newShape) {
         // Verify shape size
         const originalSize = this.numel;
         const outputSize = Tensor.shapeToSize(newShape);
         if (originalSize !== outputSize) {
-            throw new Error("Cannot reshape: incompatible sizes");
+            throw new Error("Can not reshape: incompatible sizes");
         }
+        // Create new tensor with forced compatibility (only contiguity for now)
         const outputStrides = Tensor.getStrides(newShape);
         const out = new Tensor(this.contiguous().value, { shape: newShape, strides: outputStrides, numel: outputSize });
         // Gradient reshaped and flow back to the original tensor
@@ -430,6 +454,72 @@ class Tensor {
         }
         return out;
     }
+    // Utility for indexing with array of indices
+    indexWithArray(indices) {
+        if (typeof this.value === "number")
+            return this;
+        indices = Tensor.normalizeDims(indices, this.shape[0]);
+        // Init necessary stuff for indexing
+        const reducedShape = this.shape.slice(1);
+        const reducedStrides = this.strides.slice(1);
+        const elementsPerIndex = Tensor.shapeToSize(reducedShape);
+        // Init output data
+        const outputShape = [indices.length, ...reducedShape];
+        const outputSize = Tensor.shapeToSize(outputShape);
+        const outputValue = new Array(outputSize);
+        for (let i = 0; i < indices.length; i++) {
+            const sourceRowIndex = indices[i];
+            const targetStart = i * elementsPerIndex;
+            for (let j = 0; j < elementsPerIndex; j++) {
+                const fullCoords = Tensor.indexToCoords(j, reducedStrides);
+                fullCoords.unshift(sourceRowIndex);
+                const sourceIndex = Tensor.coordsToIndex(fullCoords, this.strides);
+                outputValue[targetStart + j] = this.value[this.offset + sourceIndex];
+            }
+        }
+        const out = new Tensor(outputValue, {
+            shape: outputShape,
+            numel: outputSize
+        });
+        // Handle gradient
+        if (this.requiresGrad) {
+            out.requiresGrad = true;
+            out.children.push(this);
+            out.gradFn = () => {
+                const outGrad = out.grad;
+                // Create zero gradient tensor with original shape
+                const grad = Tensor.zerosLike(this);
+                // Scatter gradients back to original positions
+                for (let i = 0; i < indices.length; i++) {
+                    const originalRowIndex = indices[i];
+                    const sourceStart = i * elementsPerIndex;
+                    for (let j = 0; j < elementsPerIndex; j++) {
+                        const fullCoords = Tensor.indexToCoords(j, reducedStrides);
+                        fullCoords.unshift(originalRowIndex);
+                        const targetIndex = Tensor.coordsToIndex(fullCoords, this.strides);
+                        grad.value[targetIndex] += outGrad.value[sourceStart + j];
+                    }
+                }
+                Tensor.addGrad(this, grad);
+            };
+        }
+        return out;
+    }
+    // Tensor indexing
+    index(indices) {
+        if (typeof indices === "number") {
+            return this.indexWithArray([indices]).squeeze(0);
+        }
+        else {
+            const tensorIndices = this.handleOther(indices).contiguous();
+            const originalShape = tensorIndices.shape;
+            const flatIndices = tensorIndices.value;
+            const result = this.indexWithArray(flatIndices);
+            // Reshape to preserve input shape
+            const outputShape = [...originalShape, ...this.shape.slice(1)];
+            return result.reshape(outputShape);
+        }
+    }
     // Tensor slicing
     slice(ranges) {
         // Handle scalars
@@ -478,7 +568,7 @@ class Tensor {
             out.children.push(this);
             out.gradFn = () => {
                 // Create zero tensor of original shape
-                const zeroGrad = Tensor.zerosLike(this);
+                const grad = Tensor.zerosLike(this);
                 // Upstream grad
                 const outGrad = out.grad;
                 const totalElements = outGrad.numel;
@@ -497,11 +587,11 @@ class Tensor {
                     }
                     // Get flat indices with offsets
                     const srcIndex = Tensor.coordsToIndex(slicedCoords, outGrad.strides) + outGrad.offset;
-                    const targetIndex = Tensor.coordsToIndex(originalCoords, zeroGrad.strides) + zeroGrad.offset;
+                    const targetIndex = Tensor.coordsToIndex(originalCoords, grad.strides) + grad.offset;
                     // Accumulate gradient
-                    zeroGrad.value[targetIndex] += outGrad.value[srcIndex];
+                    grad.value[targetIndex] += outGrad.value[srcIndex];
                 }
-                Tensor.addGrad(this, zeroGrad);
+                Tensor.addGrad(this, grad);
             };
         }
         return out;

package/dist/nn.d.ts

@@ -57,6 +57,11 @@ declare class LayerNorm {
     constructor(normalizedShape: number | number[], eps?: number, elementwiseAffine?: boolean, bias?: boolean, device?: string);
     forward(input: Tensor): Tensor;
 }
+declare class Embedding {
+    weight: Tensor;
+    constructor(numEmbeddings: number, embeddingDim: number, device: string);
+    forward(input: Tensor | TensorValue): Tensor;
+}
 export interface StateDict {
     [key: string]: any;
 }
@@ -66,6 +71,7 @@ export declare const nn: {
     GRUCell: typeof GRUCell;
     LSTMCell: typeof LSTMCell;
     LayerNorm: typeof LayerNorm;
+    Embedding: typeof Embedding;
     state: {
         getParameters(model: any, visited?: WeakSet<object>): Tensor[];
         moveParameters(model: any, device: string): void;

package/dist/nn.js

@@ -188,6 +188,15 @@ class LayerNorm {
         return normalized;
     }
 }
+class Embedding {
+    weight;
+    constructor(numEmbeddings, embeddingDim, device) {
+        this.weight = core_1.Tensor.randn([numEmbeddings, embeddingDim], { device });
+    }
+    forward(input) {
+        return this.weight.index(input);
+    }
+}
 const state = {
     getParameters(model, visited = new WeakSet()) {
         if (visited.has(model))
@@ -256,5 +265,6 @@ exports.nn = {
     GRUCell,
     LSTMCell,
     LayerNorm,
+    Embedding,
     state
 };

package/package.json

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