catniff 0.7.4 → 0.8.0

package/dist/dtype.d.ts

@@ -0,0 +1,5 @@
+export type dtype = "float64" | "float32" | "float16" | "int32" | "int16" | "int8" | "uint32" | "uint16" | "uint8";
+export declare const dtypeHiearchy: Record<dtype, number>;
+export type MemoryBuffer = Float64Array | Float32Array | Float16Array | Int32Array | Int16Array | Int8Array | Uint32Array | Uint16Array | Uint8Array;
+export type TypedArrayConstructor = Float64ArrayConstructor | Float32ArrayConstructor | Float16ArrayConstructor | Int32ArrayConstructor | Int16ArrayConstructor | Int8ArrayConstructor | Uint32ArrayConstructor | Uint16ArrayConstructor | Uint8ArrayConstructor;
+export declare const TypedArray: Record<dtype, TypedArrayConstructor>;

package/dist/dtype.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypedArray = exports.dtypeHiearchy = void 0;
+exports.dtypeHiearchy = {
+    "float64": 8,
+    "float32": 7,
+    "float16": 6,
+    "int32": 5,
+    "int16": 4,
+    "int8": 3,
+    "uint32": 2,
+    "uint16": 1,
+    "uint8": 0
+};
+exports.TypedArray = {
+    "float64": Float64Array,
+    "float32": Float32Array,
+    "float16": Float16Array,
+    "int32": Int32Array,
+    "int16": Int16Array,
+    "int8": Int8Array,
+    "uint32": Uint32Array,
+    "uint16": Uint16Array,
+    "uint8": Uint8Array
+};

package/dist/nn.d.ts

@@ -1,8 +1,9 @@
 import { Tensor, TensorValue } from "./core";
+import { dtype } from "./dtype";
 export declare class Linear {
     weight: Tensor;
     bias?: Tensor;
-    constructor(inFeatures: number, outFeatures: number, bias?: boolean, device?: string);
+    constructor(inFeatures: number, outFeatures: number, bias?: boolean, device?: string, dtype?: dtype);
     forward(input: Tensor | TensorValue): Tensor;
 }
 export declare class RNNCell {
@@ -10,7 +11,7 @@ export declare class RNNCell {
     weightHH: Tensor;
     biasIH?: Tensor;
     biasHH?: Tensor;
-    constructor(inputSize: number, hiddenSize: number, bias?: boolean, device?: string);
+    constructor(inputSize: number, hiddenSize: number, bias?: boolean, device?: string, dtype?: dtype);
     forward(input: Tensor | TensorValue, hidden: Tensor | TensorValue): Tensor;
 }
 export declare class GRUCell {
@@ -26,7 +27,7 @@ export declare class GRUCell {
     biasHR?: Tensor;
     biasHZ?: Tensor;
     biasHN?: Tensor;
-    constructor(inputSize: number, hiddenSize: number, bias?: boolean, device?: string);
+    constructor(inputSize: number, hiddenSize: number, bias?: boolean, device?: string, dtype?: dtype);
     forward(input: Tensor | TensorValue, hidden: Tensor | TensorValue): Tensor;
 }
 export declare class LSTMCell {
@@ -46,7 +47,7 @@ export declare class LSTMCell {
     biasHF?: Tensor;
     biasHG?: Tensor;
     biasHO?: Tensor;
-    constructor(inputSize: number, hiddenSize: number, bias?: boolean, device?: string);
+    constructor(inputSize: number, hiddenSize: number, bias?: boolean, device?: string, dtype?: dtype);
     forward(input: Tensor | TensorValue, hidden: Tensor | TensorValue, cell: Tensor | TensorValue): [Tensor, Tensor];
 }
 export declare class LayerNorm {
@@ -54,19 +55,19 @@ export declare class LayerNorm {
     bias?: Tensor;
     eps: number;
     normalizedShape: number[];
-    constructor(normalizedShape: number | number[], eps?: number, elementwiseAffine?: boolean, bias?: boolean, device?: string);
+    constructor(normalizedShape: number | number[], eps?: number, elementwiseAffine?: boolean, bias?: boolean, device?: string, dtype?: dtype);
     forward(input: Tensor): Tensor;
 }
 export declare class RMSNorm {
     weight?: Tensor;
     eps: number;
     normalizedShape: number[];
-    constructor(normalizedShape: number | number[], eps?: number, elementwiseAffine?: boolean, device?: string);
+    constructor(normalizedShape: number | number[], eps?: number, elementwiseAffine?: boolean, device?: string, dtype?: dtype);
     forward(input: Tensor): Tensor;
 }
 export declare class Embedding {
     weight: Tensor;
-    constructor(numEmbeddings: number, embeddingDim: number, device: string);
+    constructor(numEmbeddings: number, embeddingDim: number, device?: string, dtype?: dtype);
     forward(input: Tensor | TensorValue): Tensor;
 }
 export declare class MultiheadAttention {
@@ -78,7 +79,7 @@ export declare class MultiheadAttention {
     numHeads: number;
     headDim: number;
     dropout: number;
-    constructor(embedDim: number, numHeads: number, dropout?: number, bias?: boolean, device?: string);
+    constructor(embedDim: number, numHeads: number, dropout?: number, bias?: boolean, device?: string, dtype?: dtype);
     forward(query: Tensor, key: Tensor, value: Tensor, needWeights?: boolean, attnMask?: Tensor, averageAttnWeights?: boolean): [Tensor, Tensor | undefined];
 }
 export interface StateDict {

package/dist/nn.js

@@ -12,11 +12,11 @@ function linearTransform(input, weight, bias) {
 class Linear {
     weight;
     bias;
-    constructor(inFeatures, outFeatures, bias = true, device) {
+    constructor(inFeatures, outFeatures, bias = true, device, dtype) {
         const bound = 1 / Math.sqrt(inFeatures);
-        this.weight = core_1.Tensor.uniform([outFeatures, inFeatures], -bound, bound, { requiresGrad: true, device });
+        this.weight = core_1.Tensor.uniform([outFeatures, inFeatures], -bound, bound, { requiresGrad: true, device, dtype });
         if (bias) {
-            this.bias = core_1.Tensor.uniform([outFeatures], -bound, bound, { requiresGrad: true, device });
+            this.bias = core_1.Tensor.uniform([outFeatures], -bound, bound, { requiresGrad: true, device, dtype });
         }
     }
     forward(input) {
@@ -40,13 +40,13 @@ class RNNCell {
     weightHH;
     biasIH;
     biasHH;
-    constructor(inputSize, hiddenSize, bias = true, device) {
+    constructor(inputSize, hiddenSize, bias = true, device, dtype) {
         const bound = 1 / Math.sqrt(hiddenSize);
-        this.weightIH = core_1.Tensor.uniform([hiddenSize, inputSize], -bound, bound, { requiresGrad: true, device });
-        this.weightHH = core_1.Tensor.uniform([hiddenSize, hiddenSize], -bound, bound, { requiresGrad: true, device });
+        this.weightIH = core_1.Tensor.uniform([hiddenSize, inputSize], -bound, bound, { requiresGrad: true, device, dtype });
+        this.weightHH = core_1.Tensor.uniform([hiddenSize, hiddenSize], -bound, bound, { requiresGrad: true, device, dtype });
         if (bias) {
-            this.biasIH = core_1.Tensor.uniform([hiddenSize], -bound, bound, { requiresGrad: true, device });
-            this.biasHH = core_1.Tensor.uniform([hiddenSize], -bound, bound, { requiresGrad: true, device });
+            this.biasIH = core_1.Tensor.uniform([hiddenSize], -bound, bound, { requiresGrad: true, device, dtype });
+            this.biasHH = core_1.Tensor.uniform([hiddenSize], -bound, bound, { requiresGrad: true, device, dtype });
         }
     }
     forward(input, hidden) {
@@ -69,21 +69,21 @@ class GRUCell {
     biasHR;
     biasHZ;
     biasHN;
-    constructor(inputSize, hiddenSize, bias = true, device) {
+    constructor(inputSize, hiddenSize, bias = true, device, dtype) {
         const bound = 1 / Math.sqrt(hiddenSize);
-        this.weightIR = core_1.Tensor.uniform([hiddenSize, inputSize], -bound, bound, { requiresGrad: true, device });
-        this.weightIZ = core_1.Tensor.uniform([hiddenSize, inputSize], -bound, bound, { requiresGrad: true, device });
-        this.weightIN = core_1.Tensor.uniform([hiddenSize, inputSize], -bound, bound, { requiresGrad: true, device });
-        this.weightHR = core_1.Tensor.uniform([hiddenSize, hiddenSize], -bound, bound, { requiresGrad: true, device });
-        this.weightHZ = core_1.Tensor.uniform([hiddenSize, hiddenSize], -bound, bound, { requiresGrad: true, device });
-        this.weightHN = core_1.Tensor.uniform([hiddenSize, hiddenSize], -bound, bound, { requiresGrad: true, device });
+        this.weightIR = core_1.Tensor.uniform([hiddenSize, inputSize], -bound, bound, { requiresGrad: true, device, dtype });
+        this.weightIZ = core_1.Tensor.uniform([hiddenSize, inputSize], -bound, bound, { requiresGrad: true, device, dtype });
+        this.weightIN = core_1.Tensor.uniform([hiddenSize, inputSize], -bound, bound, { requiresGrad: true, device, dtype });
+        this.weightHR = core_1.Tensor.uniform([hiddenSize, hiddenSize], -bound, bound, { requiresGrad: true, device, dtype });
+        this.weightHZ = core_1.Tensor.uniform([hiddenSize, hiddenSize], -bound, bound, { requiresGrad: true, device, dtype });
+        this.weightHN = core_1.Tensor.uniform([hiddenSize, hiddenSize], -bound, bound, { requiresGrad: true, device, dtype });
         if (bias) {
-            this.biasIR = core_1.Tensor.uniform([hiddenSize], -bound, bound, { requiresGrad: true, device });
-            this.biasIZ = core_1.Tensor.uniform([hiddenSize], -bound, bound, { requiresGrad: true, device });
-            this.biasIN = core_1.Tensor.uniform([hiddenSize], -bound, bound, { requiresGrad: true, device });
-            this.biasHR = core_1.Tensor.uniform([hiddenSize], -bound, bound, { requiresGrad: true, device });
-            this.biasHZ = core_1.Tensor.uniform([hiddenSize], -bound, bound, { requiresGrad: true, device });
-            this.biasHN = core_1.Tensor.uniform([hiddenSize], -bound, bound, { requiresGrad: true, device });
+            this.biasIR = core_1.Tensor.uniform([hiddenSize], -bound, bound, { requiresGrad: true, device, dtype });
+            this.biasIZ = core_1.Tensor.uniform([hiddenSize], -bound, bound, { requiresGrad: true, device, dtype });
+            this.biasIN = core_1.Tensor.uniform([hiddenSize], -bound, bound, { requiresGrad: true, device, dtype });
+            this.biasHR = core_1.Tensor.uniform([hiddenSize], -bound, bound, { requiresGrad: true, device, dtype });
+            this.biasHZ = core_1.Tensor.uniform([hiddenSize], -bound, bound, { requiresGrad: true, device, dtype });
+            this.biasHN = core_1.Tensor.uniform([hiddenSize], -bound, bound, { requiresGrad: true, device, dtype });
         }
     }
     forward(input, hidden) {
@@ -113,25 +113,25 @@ class LSTMCell {
     biasHF;
     biasHG;
     biasHO;
-    constructor(inputSize, hiddenSize, bias = true, device) {
+    constructor(inputSize, hiddenSize, bias = true, device, dtype) {
         const bound = 1 / Math.sqrt(hiddenSize);
-        this.weightII = core_1.Tensor.uniform([hiddenSize, inputSize], -bound, bound, { requiresGrad: true, device });
-        this.weightIF = core_1.Tensor.uniform([hiddenSize, inputSize], -bound, bound, { requiresGrad: true, device });
-        this.weightIG = core_1.Tensor.uniform([hiddenSize, inputSize], -bound, bound, { requiresGrad: true, device });
-        this.weightIO = core_1.Tensor.uniform([hiddenSize, inputSize], -bound, bound, { requiresGrad: true, device });
-        this.weightHI = core_1.Tensor.uniform([hiddenSize, hiddenSize], -bound, bound, { requiresGrad: true, device });
-        this.weightHF = core_1.Tensor.uniform([hiddenSize, hiddenSize], -bound, bound, { requiresGrad: true, device });
-        this.weightHG = core_1.Tensor.uniform([hiddenSize, hiddenSize], -bound, bound, { requiresGrad: true, device });
-        this.weightHO = core_1.Tensor.uniform([hiddenSize, hiddenSize], -bound, bound, { requiresGrad: true, device });
+        this.weightII = core_1.Tensor.uniform([hiddenSize, inputSize], -bound, bound, { requiresGrad: true, device, dtype });
+        this.weightIF = core_1.Tensor.uniform([hiddenSize, inputSize], -bound, bound, { requiresGrad: true, device, dtype });
+        this.weightIG = core_1.Tensor.uniform([hiddenSize, inputSize], -bound, bound, { requiresGrad: true, device, dtype });
+        this.weightIO = core_1.Tensor.uniform([hiddenSize, inputSize], -bound, bound, { requiresGrad: true, device, dtype });
+        this.weightHI = core_1.Tensor.uniform([hiddenSize, hiddenSize], -bound, bound, { requiresGrad: true, device, dtype });
+        this.weightHF = core_1.Tensor.uniform([hiddenSize, hiddenSize], -bound, bound, { requiresGrad: true, device, dtype });
+        this.weightHG = core_1.Tensor.uniform([hiddenSize, hiddenSize], -bound, bound, { requiresGrad: true, device, dtype });
+        this.weightHO = core_1.Tensor.uniform([hiddenSize, hiddenSize], -bound, bound, { requiresGrad: true, device, dtype });
         if (bias) {
-            this.biasII = core_1.Tensor.uniform([hiddenSize], -bound, bound, { requiresGrad: true, device });
-            this.biasIF = core_1.Tensor.uniform([hiddenSize], -bound, bound, { requiresGrad: true, device });
-            this.biasIG = core_1.Tensor.uniform([hiddenSize], -bound, bound, { requiresGrad: true, device });
-            this.biasIO = core_1.Tensor.uniform([hiddenSize], -bound, bound, { requiresGrad: true, device });
-            this.biasHI = core_1.Tensor.uniform([hiddenSize], -bound, bound, { requiresGrad: true, device });
-            this.biasHF = core_1.Tensor.uniform([hiddenSize], -bound, bound, { requiresGrad: true, device });
-            this.biasHG = core_1.Tensor.uniform([hiddenSize], -bound, bound, { requiresGrad: true, device });
-            this.biasHO = core_1.Tensor.uniform([hiddenSize], -bound, bound, { requiresGrad: true, device });
+            this.biasII = core_1.Tensor.uniform([hiddenSize], -bound, bound, { requiresGrad: true, device, dtype });
+            this.biasIF = core_1.Tensor.uniform([hiddenSize], -bound, bound, { requiresGrad: true, device, dtype });
+            this.biasIG = core_1.Tensor.uniform([hiddenSize], -bound, bound, { requiresGrad: true, device, dtype });
+            this.biasIO = core_1.Tensor.uniform([hiddenSize], -bound, bound, { requiresGrad: true, device, dtype });
+            this.biasHI = core_1.Tensor.uniform([hiddenSize], -bound, bound, { requiresGrad: true, device, dtype });
+            this.biasHF = core_1.Tensor.uniform([hiddenSize], -bound, bound, { requiresGrad: true, device, dtype });
+            this.biasHG = core_1.Tensor.uniform([hiddenSize], -bound, bound, { requiresGrad: true, device, dtype });
+            this.biasHO = core_1.Tensor.uniform([hiddenSize], -bound, bound, { requiresGrad: true, device, dtype });
         }
     }
     forward(input, hidden, cell) {
@@ -153,16 +153,16 @@ class LayerNorm {
     bias;
     eps;
     normalizedShape;
-    constructor(normalizedShape, eps = 1e-5, elementwiseAffine = true, bias = true, device) {
+    constructor(normalizedShape, eps = 1e-5, elementwiseAffine = true, bias = true, device, dtype) {
         this.eps = eps;
         this.normalizedShape = Array.isArray(normalizedShape) ? normalizedShape : [normalizedShape];
         if (this.normalizedShape.length === 0) {
             throw new Error("Normalized shape cannot be empty");
         }
         if (elementwiseAffine) {
-            this.weight = core_1.Tensor.ones(this.normalizedShape, { requiresGrad: true, device });
+            this.weight = core_1.Tensor.ones(this.normalizedShape, { requiresGrad: true, device, dtype });
             if (bias) {
-                this.bias = core_1.Tensor.zeros(this.normalizedShape, { requiresGrad: true, device });
+                this.bias = core_1.Tensor.zeros(this.normalizedShape, { requiresGrad: true, device, dtype });
             }
         }
     }
@@ -197,14 +197,14 @@ class RMSNorm {
     weight;
     eps;
     normalizedShape;
-    constructor(normalizedShape, eps = 1e-5, elementwiseAffine = true, device) {
+    constructor(normalizedShape, eps = 1e-5, elementwiseAffine = true, device, dtype) {
         this.eps = eps;
         this.normalizedShape = Array.isArray(normalizedShape) ? normalizedShape : [normalizedShape];
         if (this.normalizedShape.length === 0) {
             throw new Error("Normalized shape cannot be empty");
         }
         if (elementwiseAffine) {
-            this.weight = core_1.Tensor.ones(this.normalizedShape, { requiresGrad: true, device });
+            this.weight = core_1.Tensor.ones(this.normalizedShape, { requiresGrad: true, device, dtype });
         }
     }
     forward(input) {
@@ -232,8 +232,8 @@ class RMSNorm {
 exports.RMSNorm = RMSNorm;
 class Embedding {
     weight;
-    constructor(numEmbeddings, embeddingDim, device) {
-        this.weight = core_1.Tensor.randn([numEmbeddings, embeddingDim], { requiresGrad: true, device });
+    constructor(numEmbeddings, embeddingDim, device, dtype) {
+        this.weight = core_1.Tensor.randn([numEmbeddings, embeddingDim], { requiresGrad: true, device, dtype });
     }
     forward(input) {
         return this.weight.index(input);
@@ -249,11 +249,11 @@ class MultiheadAttention {
     numHeads;
     headDim;
     dropout;
-    constructor(embedDim, numHeads, dropout = 0, bias = true, device) {
-        this.qProjection = new Linear(embedDim, embedDim, bias, device);
-        this.kProjection = new Linear(embedDim, embedDim, bias, device);
-        this.vProjection = new Linear(embedDim, embedDim, bias, device);
-        this.oProjection = new Linear(embedDim, embedDim, bias, device);
+    constructor(embedDim, numHeads, dropout = 0, bias = true, device, dtype) {
+        this.qProjection = new Linear(embedDim, embedDim, bias, device, dtype);
+        this.kProjection = new Linear(embedDim, embedDim, bias, device, dtype);
+        this.vProjection = new Linear(embedDim, embedDim, bias, device, dtype);
+        this.oProjection = new Linear(embedDim, embedDim, bias, device, dtype);
         this.embedDim = embedDim;
         this.numHeads = numHeads;
         this.headDim = Math.floor(embedDim / numHeads);

package/index.d.ts

@@ -2,3 +2,4 @@ export * from "./dist/core";
 export * from "./dist/optim";
 export * from "./dist/nn";
 export * from "./dist/lrscheduler";
+export * from "./dist/dtype";

package/index.js

@@ -2,5 +2,6 @@ module.exports = {
     ...require("./dist/core"),
     ...require("./dist/optim"),
     ...require("./dist/nn"),
-    ...require("./dist/lrscheduler")
+    ...require("./dist/lrscheduler"),
+    ...require("./dist/dtype")
 };

package/package.json

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