catniff 0.8.19 → 0.8.21

package/dist/core.d.ts

@@ -66,6 +66,7 @@ export declare class Tensor {
     slice(ranges: number[][]): Tensor;
     chunk(chunks: number, dim?: number): Tensor[];
     expand(newShape: number[]): Tensor;
+    unfold(dim: number, size: number, step: number): Tensor;
     cat(other: Tensor | TensorValue, dim?: number): Tensor;
     stack(others: (Tensor | TensorValue)[], dim?: number): Tensor;
     squeeze(dims?: number[] | number): Tensor;

package/dist/core.js

@@ -551,6 +551,9 @@ class Tensor {
         if (this.shape.length === 0)
             return this;
         indices = Tensor.normalizeDims(indices, this.shape[0]);
+        if (indices.some(i => i < 0 || i >= this.shape[0])) {
+            throw new Error(`Index out of bounds for dimension 0 with size ${this.shape[0]}`);
+        }
         // Init necessary stuff for indexing
         const reducedShape = this.shape.slice(1);
         const reducedStrides = this.strides.slice(1);
@@ -618,8 +621,9 @@ class Tensor {
     // Tensor slicing
     slice(ranges) {
         // Handle scalars
-        if (this.shape.length === 0)
-            return this;
+        if (this.shape.length === 0) {
+            throw new Error("slice() cannot be applied to a 0-dim tensor");
+        }
         const newShape = [];
         const newStrides = [];
         let newOffset = this.offset;
@@ -755,6 +759,55 @@ class Tensor {
         }
         return out;
     }
+    // Tensor unfold
+    unfold(dim, size, step) {
+        // 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 unfold");
+        }
+        // Verify size and step
+        if (size <= 0 || step <= 0)
+            throw new Error("size and step must be greater than 0");
+        const dimSize = this.shape[dim];
+        // Verify size against dimension size
+        if (size > dimSize)
+            throw new Error("size can not be greater than dimension size");
+        const outSize = Math.floor((dimSize - size) / step) + 1;
+        const newShape = [...this.shape, size];
+        const newStrides = [...this.strides, this.strides[dim]];
+        newShape[dim] = outSize;
+        newStrides[dim] = this.strides[dim] * step;
+        const out = new Tensor(this.value, {
+            shape: newShape,
+            strides: newStrides,
+            offset: this.offset,
+            dtype: this.dtype,
+            device: this.device
+        });
+        if (this.requiresGrad) {
+            out.requiresGrad = true;
+            out.children.push(this);
+            out.gradFn = () => {
+                const outGrad = out.grad;
+                const grad = Tensor.zerosLike(this);
+                for (let i = 0; i < out.numel; i++) {
+                    const coords = Tensor.indexToCoords(i, newStrides);
+                    const windowIdx = coords[dim];
+                    const withinWindow = coords[coords.length - 1];
+                    coords[dim] = windowIdx * step + withinWindow;
+                    coords.pop();
+                    const sourceIdx = Tensor.coordsToIndex(coords, this.strides);
+                    grad.value[sourceIdx] += outGrad.value[i];
+                }
+                Tensor.addGrad(this, grad);
+            };
+        }
+        return out;
+    }
     // Tensor concatentation
     cat(other, dim = 0) {
         other = this.handleOther(other);

package/package.json

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