catniff 0.8.16 → 0.8.18

package/dist/core.d.ts

@@ -44,7 +44,7 @@ export declare class Tensor {
     static coordsToIndex(coords: number[], strides: number[]): number;
     static shapeToSize(shape: number[]): number;
     static getResultDtype(type1: dtype, type2: dtype): dtype;
-    handleOther(other: Tensor | TensorValue): Tensor;
+    handleOther(other: Tensor | TensorValue, forceSameDevice?: boolean): Tensor;
     static elementWiseAB(tA: Tensor, tB: Tensor, op: (tA: number, tB: number) => number): Tensor;
     static elementWiseSelf(tA: Tensor, op: (tA: number) => number): Tensor;
     elementWiseABDAG(other: TensorValue | Tensor, op: (a: number, b: number) => number, thisGrad?: (self: Tensor, other: Tensor, outGrad: Tensor) => Tensor, otherGrad?: (self: Tensor, other: Tensor, outGrad: Tensor) => Tensor): Tensor;
@@ -67,6 +67,7 @@ export declare class Tensor {
     chunk(chunks: number, dim?: number): Tensor[];
     expand(newShape: number[]): Tensor;
     cat(other: Tensor | TensorValue, dim?: number): Tensor;
+    stack(others: (Tensor | TensorValue)[], dim?: number): Tensor;
     squeeze(dims?: number[] | number): Tensor;
     unsqueeze(dim: number): Tensor;
     sort(dim?: number, descending?: boolean): Tensor;

package/dist/core.js

@@ -165,10 +165,10 @@ class Tensor {
         }
         return type2;
     }
-    // Utility to handle other tensor if an op needs a second operand
-    handleOther(other) {
+    // Utility to handle other tensor if an op needs other operands
+    handleOther(other, forceSameDevice = true) {
         if (other instanceof Tensor) {
-            if (this.device !== other.device) {
+            if (forceSameDevice && this.device !== other.device) {
                 throw new Error("Can not operate on tensors that are not on the same device");
             }
             return other;
@@ -602,7 +602,7 @@ class Tensor {
     }
     // Tensor indexing
     index(indices) {
-        const tensorIndices = this.handleOther(indices).clone();
+        const tensorIndices = this.handleOther(indices, false).clone();
         if (tensorIndices.shape.length === 0) {
             return this.indexWithArray([tensorIndices.value[0]]).squeeze(0);
         }
@@ -843,6 +843,15 @@ class Tensor {
         }
         return out;
     }
+    // Tensor stack
+    stack(others, dim = 0) {
+        let out = this.unsqueeze(dim);
+        for (let index = 0; index < others.length; index++) {
+            const other = this.handleOther(others[index]).unsqueeze(dim);
+            out = out.cat(other, dim);
+        }
+        return out;
+    }
     // Tensor squeeze
     squeeze(dims) {
         if (this.shape.length === 0)

package/dist/lrscheduler.d.ts

@@ -30,8 +30,20 @@ export declare class CosineAnnealingLR {
     constructor(optimizer: OptimizerWithLR, TMax: number, etaMin?: number, lastEpoch?: number);
     step(): void;
 }
+export interface Scheduler {
+    step: Function;
+}
+export declare class SequentialLR {
+    optimizer: OptimizerWithLR;
+    schedulers: Scheduler[];
+    milestones: number[];
+    lastEpoch: number;
+    constructor(optimizer: OptimizerWithLR, schedulers: Scheduler[], milestones: number[], lastEpoch?: number);
+    step(): void;
+}
 export declare const LRScheduler: {
     StepLR: typeof StepLR;
     LinearLR: typeof LinearLR;
     CosineAnnealingLR: typeof CosineAnnealingLR;
+    SequentialLR: typeof SequentialLR;
 };

package/dist/lrscheduler.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LRScheduler = exports.CosineAnnealingLR = exports.LinearLR = exports.StepLR = void 0;
+exports.LRScheduler = exports.SequentialLR = exports.CosineAnnealingLR = exports.LinearLR = exports.StepLR = void 0;
 class StepLR {
     optimizer;
     stepSize;
@@ -84,8 +84,33 @@ class CosineAnnealingLR {
     }
 }
 exports.CosineAnnealingLR = CosineAnnealingLR;
+class SequentialLR {
+    optimizer;
+    schedulers;
+    milestones;
+    lastEpoch;
+    constructor(optimizer, schedulers, milestones, lastEpoch = -1) {
+        this.optimizer = optimizer;
+        this.schedulers = schedulers;
+        this.milestones = milestones;
+        this.lastEpoch = lastEpoch;
+    }
+    step() {
+        this.lastEpoch++;
+        let schedulerIndex = this.schedulers.length - 1; // default to last
+        for (let index = 0; index < this.milestones.length; index++) {
+            if (this.lastEpoch < this.milestones[index]) {
+                schedulerIndex = index;
+                break;
+            }
+        }
+        this.schedulers[schedulerIndex].step();
+    }
+}
+exports.SequentialLR = SequentialLR;
 exports.LRScheduler = {
     StepLR,
     LinearLR,
-    CosineAnnealingLR
+    CosineAnnealingLR,
+    SequentialLR
 };

package/package.json

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