catniff 0.6.9 → 0.6.11

package/README.md

@@ -1,4 +1,4 @@
-# Catniff
+# Catniff 😺🌿
 
 Catniff is a small deep learning framework for Javacript, built to be Torch-like, but more direct on tensors and autograd usage like Tinygrad. This project is under development currently, so keep in mind that APIs can be unstable and backwards-incompatible. On a side-note, the name is a play on "catnip" and "differentiation".
 

package/dist/core.d.ts

@@ -89,6 +89,7 @@ export declare class Tensor {
     var(dims?: number[] | number, keepDims?: boolean): Tensor;
     std(dims?: number[] | number, keepDims?: boolean): Tensor;
     softmax(dim?: number): Tensor;
+    softmin(dim?: number): Tensor;
     add(other: TensorValue | Tensor): Tensor;
     sub(other: TensorValue | Tensor): Tensor;
     subtract: (other: TensorValue | Tensor) => Tensor;
@@ -158,6 +159,10 @@ export declare class Tensor {
     log10(): Tensor;
     log1p(): Tensor;
     relu(): Tensor;
+    leakyRelu(negativeSlope?: number): Tensor;
+    elu(alpha?: number): Tensor;
+    selu(): Tensor;
+    celu(alpha?: number): Tensor;
     sigmoid(): Tensor;
     tanh(): Tensor;
     softplus(): Tensor;

package/dist/core.js

@@ -329,7 +329,7 @@ class Tensor {
         // Verify shape size
         const originalSize = this.numel;
         const outputSize = Tensor.shapeToSize(newShape);
-        if (originalSize !== outputSize) {
+        if (originalSize !== outputSize || typeof this.value === "number") {
             throw new Error("Can not create view: incompatible sizes");
         }
         // Verify compatibility (only contiguity for now)
@@ -357,7 +357,7 @@ class Tensor {
         // Verify shape size
         const originalSize = this.numel;
         const outputSize = Tensor.shapeToSize(newShape);
-        if (originalSize !== outputSize) {
+        if (originalSize !== outputSize || typeof this.value === "number") {
             throw new Error("Can not reshape: incompatible sizes");
         }
         // Create new tensor with forced compatibility (only contiguity for now)
@@ -645,6 +645,10 @@ class Tensor {
         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 do not exist to chunk");
+        }
         const sliceOpt = new Array(this.shape.length);
         for (let index = 0; index < sliceOpt.length; index++) {
             sliceOpt[index] = [];
@@ -907,14 +911,37 @@ class Tensor {
         if (typeof this.value === "number")
             return this;
         // Handle negative indexing
-        if (dim < 0)
-            dim = this.shape.length + dim;
+        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 do not exist to apply softmax");
+        }
         const maxVals = this.max(dim, true);
         const shifted = this.sub(maxVals);
         const expVals = shifted.exp();
         const sumExp = expVals.sum(dim, true);
         return expVals.div(sumExp);
     }
+    // Tensor softmin
+    softmin(dim = -1) {
+        if (typeof this.value === "number")
+            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 do not exist to apply softmin");
+        }
+        const maxVals = this.max(dim, true);
+        const shifted = maxVals.sub(this);
+        const expVals = shifted.exp();
+        const sumExp = expVals.sum(dim, true);
+        return expVals.div(sumExp);
+    }
     // Tensor element-wise addition
     add(other) {
         return this.elementWiseABDAG(other, (a, b) => a + b, (self, other, outGrad) => outGrad, (self, other, outGrad) => outGrad);
@@ -1137,6 +1164,32 @@ class Tensor {
     relu() {
         return this.elementWiseSelfDAG((a) => Math.max(a, 0), (self, outGrad) => outGrad.mul(self.gt(0)));
     }
+    // Tensor element-wise leaky relu
+    leakyRelu(negativeSlope = 0.01) {
+        return this.elementWiseSelfDAG((a) => Math.max(a, 0) + negativeSlope * Math.min(a, 0), (self, outGrad) => {
+            return outGrad.mul(self.gt(0).add(self.le(0).mul(negativeSlope)));
+        });
+    }
+    // Tensor element-wise elu
+    elu(alpha = 1) {
+        return this.elementWiseSelfDAG((a) => a > 0 ? a : alpha * (Math.expm1(a)), (self, outGrad) => {
+            return outGrad.mul(self.gt(0).add(self.le(0).mul(self.exp().mul(alpha))));
+        });
+    }
+    // Tensor element-wise selu
+    selu() {
+        const alpha = 1.6732632423543772848170429916717;
+        const scale = 1.0507009873554804934193349852946;
+        return this.elementWiseSelfDAG((a) => scale * (a >= 0 ? a : alpha * Math.expm1(a)), (self, outGrad) => {
+            return outGrad.mul(self.gt(0).mul(scale).add(self.le(0).mul(self.exp().mul(alpha * scale))));
+        });
+    }
+    // Tensor element-wise celu
+    celu(alpha = 1) {
+        return this.elementWiseSelfDAG((a) => a >= 0 ? a : alpha * (Math.expm1(a / alpha)), (self, outGrad) => {
+            return outGrad.mul(self.gt(0).add(self.le(0).mul(self.div(alpha).exp())));
+        });
+    }
     // Tensor element-wise sigmoid
     sigmoid() {
         return this.elementWiseSelfDAG((a) => 1 / (1 + Math.exp(-a)), (self, outGrad) => {

package/dist/optim.d.ts

@@ -55,10 +55,10 @@ declare class AdamW extends BaseOptimizer {
     constructor(params: Tensor[], options?: AdamWOptions);
     step(): void;
 }
-export declare class Optim {
-    static BaseOptimizer: typeof BaseOptimizer;
-    static SGD: typeof SGD;
-    static Adam: typeof Adam;
-    static AdamW: typeof AdamW;
-}
+export declare const Optim: {
+    BaseOptimizer: typeof BaseOptimizer;
+    SGD: typeof SGD;
+    Adam: typeof Adam;
+    AdamW: typeof AdamW;
+};
 export {};

package/dist/optim.js

@@ -184,10 +184,9 @@ class AdamW extends BaseOptimizer {
         }
     }
 }
-class Optim {
-    static BaseOptimizer = BaseOptimizer;
-    static SGD = SGD;
-    static Adam = Adam;
-    static AdamW = AdamW;
-}
-exports.Optim = Optim;
+exports.Optim = {
+    BaseOptimizer,
+    SGD,
+    Adam,
+    AdamW
+};

package/package.json

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