catniff 0.2.10 → 0.2.11

package/dist/core.d.ts

@@ -112,6 +112,12 @@ export declare class Tensor {
     relu(): Tensor;
     sigmoid(): Tensor;
     tanh(): Tensor;
+    softplus(): Tensor;
+    softsign(): Tensor;
+    silu(): Tensor;
+    mish(): Tensor;
+    maximum(other: TensorValue | Tensor): Tensor;
+    minimum(other: TensorValue | Tensor): Tensor;
     round(): Tensor;
     floor(): Tensor;
     ceil(): Tensor;
@@ -120,6 +126,9 @@ export declare class Tensor {
     frac(): Tensor;
     clip(min: number, max: number): Tensor;
     clamp: (min: number, max: number) => Tensor;
+    erf(): Tensor;
+    erfc(): Tensor;
+    erfinv(): Tensor;
     transpose(dim1: number, dim2: number): Tensor;
     swapaxes: (dim1: number, dim2: number) => Tensor;
     swapdims: (dim1: number, dim2: number) => Tensor;

package/dist/core.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Tensor = void 0;
+const utils_1 = require("./utils");
 class Tensor {
     value;
     shape;
@@ -534,7 +535,7 @@ class Tensor {
     }
     // Tensor element-wise division
     div(other) {
-        return this.elementWiseABDAG(other, (a, b) => a / b, (self, other, outGrad) => outGrad.div(other), (self, other, outGrad) => outGrad.mul(self.neg().div(other.pow(2))));
+        return this.elementWiseABDAG(other, (a, b) => a / b, (self, other, outGrad) => outGrad.div(other), (self, other, outGrad) => outGrad.mul(self.neg().div(other.square())));
     }
     divide = this.div;
     // Tensor element-wise modulo
@@ -618,7 +619,7 @@ class Tensor {
     negative = this.neg;
     // Tensor element-wise reciprocal
     reciprocal() {
-        return this.elementWiseSelfDAG((a) => 1 / a, (self, outGrad) => outGrad.mul(self.neg().pow(-2)));
+        return this.elementWiseSelfDAG((a) => 1 / a, (self, outGrad) => outGrad.mul(self.pow(-2).neg()));
     }
     // Tensor element-wise square
     square() {
@@ -643,21 +644,21 @@ class Tensor {
     }
     // Tensor element-wise tan
     tan() {
-        return this.elementWiseSelfDAG((a) => Math.tan(a), (self, outGrad) => outGrad.mul(self.tan().pow(2).add(1)));
+        return this.elementWiseSelfDAG((a) => Math.tan(a), (self, outGrad) => outGrad.mul(self.tan().square().add(1)));
     }
     // Tensor element-wise asin
     asin() {
-        return this.elementWiseSelfDAG((a) => Math.asin(a), (self, outGrad) => outGrad.div(self.pow(2).neg().add(1).sqrt()));
+        return this.elementWiseSelfDAG((a) => Math.asin(a), (self, outGrad) => outGrad.div(self.square().neg().add(1).sqrt()));
     }
     arcsin = this.asin;
     // Tensor element-wise acos
     acos() {
-        return this.elementWiseSelfDAG((a) => Math.acos(a), (self, outGrad) => outGrad.div(self.pow(2).neg().add(1).sqrt()).neg());
+        return this.elementWiseSelfDAG((a) => Math.acos(a), (self, outGrad) => outGrad.div(self.square().neg().add(1).sqrt()).neg());
     }
     arccos = this.acos;
     // Tensor element-wise atan
     atan() {
-        return this.elementWiseSelfDAG((a) => Math.atan(a), (self, outGrad) => outGrad.div(self.pow(2).add(1)));
+        return this.elementWiseSelfDAG((a) => Math.atan(a), (self, outGrad) => outGrad.div(self.square().add(1)));
     }
     arctan = this.atan;
     // Tensor element-wise atan2
@@ -675,7 +676,7 @@ class Tensor {
     }
     // Tensor element-wise asinh
     asinh() {
-        return this.elementWiseSelfDAG((a) => Math.asinh(a), (self, outGrad) => outGrad.div(self.pow(2).add(1).sqrt()));
+        return this.elementWiseSelfDAG((a) => Math.asinh(a), (self, outGrad) => outGrad.div(self.square().add(1).sqrt()));
     }
     arcsinh = this.asinh;
     // Tensor element-wise acosh
@@ -685,7 +686,7 @@ class Tensor {
     arccosh = this.acosh;
     // Tensor element-wise atanh
     atanh() {
-        return this.elementWiseSelfDAG((a) => Math.atanh(a), (self, outGrad) => outGrad.div(self.pow(2).neg().add(1)));
+        return this.elementWiseSelfDAG((a) => Math.atanh(a), (self, outGrad) => outGrad.div(self.square().neg().add(1)));
     }
     arctanh = this.atanh;
     // Tensor element-wise degree to radian
@@ -734,7 +735,7 @@ class Tensor {
     }
     // Tensor element-wise relu
     relu() {
-        return this.elementWiseSelfDAG((a) => Math.max(a, 0), (self, outGrad) => outGrad.mul(self.ge(0)));
+        return this.elementWiseSelfDAG((a) => Math.max(a, 0), (self, outGrad) => outGrad.mul(self.gt(0)));
     }
     // Tensor element-wise sigmoid
     sigmoid() {
@@ -745,7 +746,39 @@ class Tensor {
     }
     // Tensor element-wise tanh
     tanh() {
-        return this.elementWiseSelfDAG((a) => Math.tanh(a), (self, outGrad) => outGrad.mul(self.tanh().pow(2).neg().add(1)));
+        return this.elementWiseSelfDAG((a) => Math.tanh(a), (self, outGrad) => outGrad.mul(self.tanh().square().neg().add(1)));
+    }
+    // Tensor element-wise softplus
+    softplus() {
+        return this.elementWiseSelfDAG((a) => Math.log1p(Math.exp(a)), (self, outGrad) => outGrad.mul(self.sigmoid()));
+    }
+    // Tensor element-wise softsign
+    softsign() {
+        return this.elementWiseSelfDAG((a) => a / (1 + Math.abs(a)), (self, outGrad) => outGrad.div(self.abs().add(1).square()));
+    }
+    // Tensor element-wise silu (swish)
+    silu() {
+        return this.elementWiseSelfDAG((a) => a / (1 + Math.exp(-a)), (self, outGrad) => {
+            const sig = self.sigmoid();
+            return outGrad.mul(sig.add(self.mul(sig).mul(sig.neg().add(1))));
+        });
+    }
+    // Tensor element-wise mish
+    mish() {
+        return this.elementWiseSelfDAG((a) => a * Math.tanh(Math.log1p(Math.exp(a))), (self, outGrad) => {
+            const tanhSoftPlus = self.exp().add(1).log().tanh();
+            // tanh(softplus(x)) + x * (1 - tanh²(softplus(x))) * sigmoid(x)
+            const derivative = tanhSoftPlus.add(self.mul(tanhSoftPlus.square().neg().add(1)).mul(self.sigmoid()));
+            return outGrad.mul(derivative);
+        });
+    }
+    // Tensor element-wise maximum
+    maximum(other) {
+        return this.elementWiseABDAG(other, (a, b) => Math.max(a, b), (self, other, outGrad) => outGrad.mul(self.gt(other).add(self.eq(other).mul(0.5))), (self, other, outGrad) => outGrad.mul(other.gt(self).add(other.eq(self).mul(0.5))));
+    }
+    // Tensor element-wise minimum
+    minimum(other) {
+        return this.elementWiseABDAG(other, (a, b) => Math.min(a, b), (self, other, outGrad) => outGrad.mul(self.lt(other).add(self.eq(other).mul(0.5))), (self, other, outGrad) => outGrad.mul(other.lt(self).add(other.eq(self).mul(0.5))));
     }
     // Tensor element-wise round
     round() {
@@ -773,6 +806,18 @@ class Tensor {
         return this.elementWiseSelfDAG((a) => Math.max(min, Math.min(max, a)), (self, outGrad) => outGrad.mul(self.ge(min).mul(self.le(max))));
     }
     clamp = this.clip;
+    // Tensor element-wise error function
+    erf() {
+        return this.elementWiseSelfDAG((a) => (0, utils_1.erf)(a), (self, outGrad) => outGrad.mul(self.square().neg().exp().mul(2 / Math.sqrt(Math.PI))));
+    }
+    // Tensor element-wise complementary error function
+    erfc() {
+        return this.elementWiseSelfDAG((a) => (0, utils_1.erfc)(a), (self, outGrad) => outGrad.mul(self.square().neg().exp().mul(2 / Math.sqrt(Math.PI)).neg()));
+    }
+    // Tensor element-wise inverse error function
+    erfinv() {
+        return this.elementWiseSelfDAG((a) => (0, utils_1.erfinv)(a), (self, outGrad) => outGrad.mul(self.erfinv().square().exp().mul(Math.sqrt(Math.PI) / 2)));
+    }
     // Transpose
     transpose(dim1, dim2) {
         // If dimension out of bound, throw error

package/dist/utils.d.ts

@@ -0,0 +1,3 @@
+export declare function erf(x: number): number;
+export declare function erfc(x: number): number;
+export declare function erfinv(x: number): number;

package/dist/utils.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.erf = erf;
+exports.erfc = erfc;
+exports.erfinv = erfinv;
+// Error function using Abramowitz and Stegun approximation
+function erf(x) {
+    const a1 = 0.254829592;
+    const a2 = -0.284496736;
+    const a3 = 1.421413741;
+    const a4 = -1.453152027;
+    const a5 = 1.061405429;
+    const p = 0.3275911;
+    const sign = x >= 0 ? 1 : -1;
+    x = Math.abs(x);
+    // Formula 7.1.26
+    const t = 1.0 / (1.0 + p * x);
+    const y = 1.0 - (((((a5 * t + a4) * t) + a3) * t + a2) * t + a1) * t * Math.exp(-x * x);
+    return sign * y;
+}
+// Complementary error function
+function erfc(x) {
+    return 1 - erf(x);
+}
+// Inverse error function using Winitzki approximation
+function erfinv(x) {
+    if (Math.abs(x) >= 1)
+        throw new Error("Input must be in range (-1, 1)");
+    const a = 0.147;
+    const ln = Math.log(1 - x * x);
+    const part1 = 2 / (Math.PI * a) + ln / 2;
+    const part2 = ln / a;
+    const sign = x >= 0 ? 1 : -1;
+    return sign * Math.sqrt(-part1 + Math.sqrt(part1 * part1 - part2));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "catniff",
-  "version": "0.2.10",
+  "version": "0.2.11",
   "description": "A cute autograd engine for Javascript",
   "main": "index.js",
   "scripts": {