@genai-fi/nanogpt 0.20.0 → 0.20.2

package/dist/ops/transpose16.js

@@ -0,0 +1,32 @@
+import { Fi as e, Ii as t, On as n, ii as r, w as i } from "../dist-BewPQWjc.js";
+import { forceFloat as a, forcePacked as o } from "./grads/utils.js";
+import { isPackedTensor as s } from "../utilities/packed.js";
+//#region lib/ops/transpose16.ts
+var c = {
+	kernelName: "Transpose16",
+	gradFunc: (e, t, r) => {
+		if (Array.isArray(e)) throw Error("Transpose16 gradient does not support multiple outputs.");
+		let { perm: i } = r, a = n(i);
+		return { x: () => u(e, a) };
+	}
+};
+e(c);
+function l(e) {
+	let { inputs: t, attrs: n } = e, { x: r } = t, { perm: c } = n, l = s(r);
+	if (l && c[c.length - 1] !== r.shape.length - 1) throw Error("Transpose16 currently only supports the last axis being unchanged.");
+	return l ? o(i(a(r), c)) : i(r, c);
+}
+t({
+	kernelName: "Transpose16",
+	backendName: "webgl",
+	kernelFunc: l
+}), t({
+	kernelName: "Transpose16",
+	backendName: "cpu",
+	kernelFunc: l
+});
+function u(e, t) {
+	return t ??= e.shape.map((e, t) => t).reverse(), r().runKernel("Transpose16", { x: e }, { perm: t });
+}
+//#endregion
+export { u as transpose16, c as transpose16GradConfig };

package/dist/ops/unpack16.d.ts

@@ -0,0 +1,2 @@
+import { Tensor } from '@tensorflow/tfjs-core';
+export declare function unpack16(x: Tensor, scaling?: number, disposeArg?: boolean): Tensor;

package/dist/ops/unpack16.js

@@ -0,0 +1,2 @@
+import { r as e } from "../pack16-Ck-spx_F.js";
+export { e as unpack16 };

package/dist/ops/webgl/adamAdjust.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/ops/webgl/adamAdjust.js

@@ -0,0 +1,82 @@
+import { Ii as e } from "../../dist-BewPQWjc.js";
+import { t } from "../../Reshape-CABOPB9d.js";
+//#region lib/ops/webgl/adamAdjust.ts
+var n = class {
+	variableNames = ["moments", "value"];
+	outputShape;
+	userCode;
+	customUniforms = [
+		{
+			name: "invBeta1",
+			type: "float"
+		},
+		{
+			name: "invBeta2",
+			type: "float"
+		},
+		{
+			name: "learningRate",
+			type: "float"
+		},
+		{
+			name: "epsilon",
+			type: "float"
+		}
+	];
+	constructor(e, t) {
+		this.outputShape = e, t && this.customUniforms.push({
+			name: "weightDecay",
+			type: "float"
+		}), this.userCode = `
+        void main() {
+            float v = getValueAtOutCoords();
+            int coords = getOutputCoords();
+            coords *= 2;
+            float m1 = getMoments(coords);
+            float m2 = getMoments(coords + 1);
+
+            float m1Hat = m1 * invBeta1;
+            float m2Hat = m2 * invBeta2;
+
+            float invSqrt = inversesqrt(max(m2Hat, 1e-30));
+            float invDenom = invSqrt / (1.0 + epsilon * invSqrt);
+            float adjustedValue = -learningRate * m1Hat * invDenom + v;
+
+            ${t ? "adjustedValue = adjustedValue - learningRate * weightDecay * v;" : ""}
+
+            setOutput(adjustedValue);
+        }
+        `;
+	}
+};
+function r(e) {
+	let { moments: r, value: i } = e.inputs, { beta1: a, beta2: o, learningRate: s, epsilon: c, weightDecay: l } = e.attrs, u = e.backend, d = t({
+		inputs: { x: r },
+		backend: u,
+		attrs: { shape: [-1] }
+	}), f = t({
+		inputs: { x: i },
+		backend: u,
+		attrs: { shape: [-1] }
+	}), p = new n(f.shape, l > 0), m = [
+		[1 / a],
+		[1 / o],
+		[s],
+		[c]
+	];
+	l > 0 && m.push([l]);
+	let h = u.runWebGLProgram(p, [d, f], "float32", m);
+	u.disposeIntermediateTensorInfo(d), u.disposeIntermediateTensorInfo(f);
+	let g = t({
+		inputs: { x: h },
+		backend: u,
+		attrs: { shape: i.shape }
+	});
+	return u.disposeIntermediateTensorInfo(h), g;
+}
+e({
+	kernelName: "AdamAdjust",
+	backendName: "webgl",
+	kernelFunc: r
+});
+//#endregion

package/dist/ops/webgl/adamMoments.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/ops/webgl/adamMoments.js

@@ -0,0 +1,44 @@
+import { Ii as e } from "../../dist-BewPQWjc.js";
+//#region lib/ops/webgl/adamMoments.ts
+var t = class {
+	variableNames = ["moments", "gradient"];
+	outputShape;
+	userCode;
+	customUniforms = [{
+		name: "beta1",
+		type: "float"
+	}, {
+		name: "beta2",
+		type: "float"
+	}];
+	constructor(e) {
+		this.outputShape = e;
+		let t = e.length, n = t === 1 ? "int" : `ivec${Math.min(t, 4)}`, r = t === 1 ? "coords" : `coords[${t - 1}]`, i = t === 1 ? "coords" : e.slice(0, -1).map((e, t) => `coords[${t}]`).join(", ");
+		this.userCode = `
+        void main() {
+            float m = getMomentsAtOutCoords();
+            ${n} coords = getOutputCoords();
+
+            // Add gradient clipping here
+            float g = clamp(getGradient(${i}), -1.0, 1.0);
+            int which = ${r};
+
+            float beta = which == 0 ? beta1 : beta2;
+            float gg = which == 0 ? g : g * g;
+    
+            float newM = m * beta + gg * (1.0 - beta);
+            setOutput(newM);
+        }
+        `;
+	}
+};
+function n(e) {
+	let { moments: n, gradient: r } = e.inputs, { beta1: i, beta2: a } = e.attrs, o = e.backend, s = new t(n.shape);
+	return o.runWebGLProgram(s, [n, r], "float32", [[i], [a]]);
+}
+e({
+	kernelName: "AdamMoments",
+	backendName: "webgl",
+	kernelFunc: n
+});
+//#endregion

package/dist/ops/webgl/appendCache.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/ops/webgl/appendCache.js

@@ -0,0 +1,53 @@
+import { Ii as e } from "../../dist-BewPQWjc.js";
+//#region lib/ops/webgl/appendCache.ts
+var t = class {
+	variableNames = ["cache", "item"];
+	outputShape;
+	userCode;
+	customUniforms = [{
+		name: "cacheT",
+		type: "int"
+	}];
+	constructor(e, t, n, r, i) {
+		let a = Math.min(n + 1, i);
+		this.outputShape = [
+			e,
+			t,
+			a,
+			r
+		], this.userCode = `
+        void main() {
+            ivec4 coords = getOutputCoords(); // [b, h, t, d]
+            int b = coords.x;
+            int h = coords.y;
+            int t = coords.z;
+            int d = coords.w;
+
+            int itemT = 1;
+            int maxSize = ${i};
+            int totalT = cacheT + itemT;
+            int start = totalT >= maxSize ? 1 : 0;
+
+            int srcT = t + start;
+            float val = 0.0;
+            if (srcT < cacheT) {
+                val = getCache(b, h, srcT, d);
+            } else if (srcT == cacheT) {
+                val = getItem(b, h, 0, d);
+            } else {
+                val = 0.0;}
+            setOutput(val);
+        }
+        `;
+	}
+};
+function n(e) {
+	let { cache: n, item: r } = e.inputs, { maxSize: i, pastLen: a } = e.attrs, o = e.backend, s = n.shape[0], c = n.shape[2], l = n.shape[1], u = new t(s, l, c, r.shape[3], i);
+	return o.runWebGLProgram(u, [n, r], "float32", [[a]]);
+}
+e({
+	kernelName: "AppendCache",
+	backendName: "webgl",
+	kernelFunc: n
+});
+//#endregion

package/dist/ops/webgl/attentionMask.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/ops/webgl/attentionMask.js

@@ -0,0 +1,64 @@
+import { Ii as e } from "../../dist-BewPQWjc.js";
+//#region lib/ops/webgl/attentionMask.ts
+var t = class {
+	variableNames = ["q", "k"];
+	outputShape;
+	userCode;
+	customUniforms = [
+		{
+			name: "divisor",
+			type: "float"
+		},
+		{
+			name: "pastLen",
+			type: "int"
+		},
+		{
+			name: "inf",
+			type: "float"
+		}
+	];
+	constructor(e, t, n, r, i) {
+		this.outputShape = [
+			e,
+			t,
+			n,
+			r
+		], this.userCode = `
+        void main() {
+            ivec4 coords = getOutputCoords(); // [batch, nh, t1, t2]
+            int b = coords.x;
+            int h = coords.y;
+            int t1 = coords.z;
+            int t2 = coords.w;
+
+            float sum = 0.0;
+            for (int i = 0; i < ${i}; ++i) {
+                float qv = getQ(b, h, t1, i);
+                float kv = getK(b, h, t2, i);
+                sum += qv * kv;
+            }
+
+            // Scale by divisor
+            float scaled = sum * divisor;
+
+            // Mask out future positions
+            setOutput((t2 > t1 + pastLen) ? inf : scaled);
+        }
+        `;
+	}
+};
+function n(e) {
+	let { q: n, k: r } = e.inputs, { divisor: i, pastLen: a } = e.attrs, o = e.backend, s = n.shape[0], c = n.shape[2], l = r.shape[2], u = n.shape[1], d = n.shape[3], f = new t(s, u, c, l, d);
+	return o.runWebGLProgram(f, [n, r], "float32", [
+		[i],
+		[a],
+		[-Infinity]
+	]);
+}
+e({
+	kernelName: "AttentionMask",
+	backendName: "webgl",
+	kernelFunc: n
+});
+//#endregion

package/dist/ops/webgl/dropout16.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/ops/webgl/dropout16.js

@@ -0,0 +1,12 @@
+import { Ii as e } from "../../dist-BewPQWjc.js";
+//#region lib/ops/webgl/dropout16.ts
+function t(e) {
+	let { x: t } = e.inputs;
+	return t;
+}
+e({
+	kernelName: "Dropout16",
+	backendName: "webgl",
+	kernelFunc: t
+});
+//#endregion

package/dist/ops/webgl/fusedSoftmax.d.ts

@@ -0,0 +1,11 @@
+import { SoftmaxAttrs, SoftmaxInputs, TensorInfo } from '@tensorflow/tfjs-core';
+interface FusedSoftmaxAttrs extends SoftmaxAttrs {
+    dropoutRate?: number;
+    seed?: number;
+}
+export declare function softmax(args: {
+    inputs: SoftmaxInputs;
+    backend: unknown;
+    attrs: FusedSoftmaxAttrs;
+}): TensorInfo;
+export {};

package/dist/ops/webgl/fusedSoftmax.js

@@ -0,0 +1,70 @@
+import { Ii as e, Tn as t, nc as n } from "../../dist-BewPQWjc.js";
+import { t as r } from "../../Reshape-CABOPB9d.js";
+import { a as i, r as a, t as o } from "../../RealDiv-DBu0FQqT.js";
+//#region lib/ops/webgl/fusedSoftmax.ts
+var s = class {
+	variableNames = ["logits", "maxLogits"];
+	outputShape;
+	userCode;
+	constructor(e) {
+		this.outputShape = e, this.userCode = "\n        void main() {\n        ivec4 coords = getOutputCoords(); // [batch, nh, t1, t2]\n            int b = coords.x;\n            int h = coords.y;\n            int t1 = coords.z;\n            int t2 = coords.w;\n            float x = getLogitsAtOutCoords();\n            float maxLogit = getMaxLogits(b, h, t1);\n            setOutput(exp(x - maxLogit));\n        }\n        ";
+	}
+}, c = class {
+	variableNames = ["exp", "sum"];
+	outputShape;
+	userCode;
+	customUniforms = [{
+		name: "dropoutRate",
+		type: "float"
+	}, {
+		name: "seed",
+		type: "float"
+	}];
+	constructor(e) {
+		this.outputShape = e, this.userCode = "\n        float random(ivec4 coords) {\n            float x = float(coords.x * 4096 + coords.y * 256 + coords.z * 16 + coords.w);\n            return fract(sin(seed + x) * 43758.5453123);\n        }\n        void main() {\n            ivec4 coords = getOutputCoords();\n            float numerator = getExp(coords.x, coords.y, coords.z, coords.w);\n            float denominator = getSum(coords.x, coords.y, coords.z, coords.w);\n            float val = numerator / denominator;\n            float keepProb = 1.0 - dropoutRate;\n            float rand = random(coords);\n            float mask = step(rand, keepProb);\n            setOutput(val * mask / keepProb);\n        }\n        ";
+	}
+};
+function l(e) {
+	let { inputs: l, attrs: u } = e, { logits: d } = l, { dim: f, dropoutRate: p, seed: m } = u, h = e.backend;
+	if (!d) throw Error("Error in softmax: input logits is null");
+	let g = n([f], d.shape), _ = a({
+		inputs: { x: d },
+		backend: h,
+		attrs: {
+			reductionIndices: g,
+			keepDims: !1
+		}
+	}), v = t(_.shape, g), y = new s(d.shape), b = h.runWebGLProgram(y, [d, _], "float32");
+	h.disposeIntermediateTensorInfo(_);
+	let x = i({
+		inputs: { x: b },
+		backend: h,
+		attrs: {
+			axis: g,
+			keepDims: !1
+		}
+	}), S = r({
+		inputs: { x },
+		backend: h,
+		attrs: { shape: v }
+	});
+	if (p !== void 0 && p > 0) {
+		let e = new c(d.shape), t = h.runWebGLProgram(e, [b, S], "float32", [[p], [m ?? Math.random() * 1e4]]);
+		return h.disposeIntermediateTensorInfo(b), h.disposeIntermediateTensorInfo(x), h.disposeIntermediateTensorInfo(S), t;
+	}
+	let C = o({
+		inputs: {
+			a: b,
+			b: S
+		},
+		backend: h
+	});
+	return h.disposeIntermediateTensorInfo(b), h.disposeIntermediateTensorInfo(x), h.disposeIntermediateTensorInfo(S), C;
+}
+e({
+	kernelName: "FusedSoftmax",
+	backendName: "webgl",
+	kernelFunc: l
+});
+//#endregion
+export { l as softmax };

package/dist/ops/webgl/gatherSub.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/ops/webgl/gatherSub.js

@@ -0,0 +1,28 @@
+import { Ii as e } from "../../dist-BewPQWjc.js";
+//#region lib/ops/webgl/gatherSub.ts
+var t = class {
+	variableNames = [
+		"labels",
+		"logits",
+		"values"
+	];
+	outputShape;
+	userCode;
+	constructor(e) {
+		this.outputShape = [e], this.userCode = "\n          void main() {\n              int coords = getOutputCoords();\n              int index = int(getLabelsAtOutCoords());\n              float val = getValuesAtOutCoords();\n              float logit = getLogits(coords, index);\n              setOutput(val - logit);\n          }\n    ";
+	}
+};
+function n(e) {
+	let { logits: n, labels: r, values: i } = e.inputs, a = e.backend, o = r.shape[0], s = new t(o);
+	return a.runWebGLProgram(s, [
+		r,
+		n,
+		i
+	], "float32");
+}
+e({
+	kernelName: "EfficientGatherSub",
+	backendName: "webgl",
+	kernelFunc: n
+});
+//#endregion

package/dist/ops/webgl/gelu.d.ts

@@ -0,0 +1,2 @@
+import { KernelFunc } from '@tensorflow/tfjs-core';
+export declare const gelu: KernelFunc;

package/dist/ops/webgl/gelu.js

@@ -0,0 +1,48 @@
+import { Ii as e } from "../../dist-BewPQWjc.js";
+import { _ as t, i as n } from "../../kernel_funcs_utils-HiXOOx3f.js";
+//#region lib/ops/webgl/gelu.ts
+var r = .7978845608028654, i = .044715, a = n({ opSnippet: t + `
+    float x3 = x * x * x;
+    float inner = x + ${i} * x3;
+    inner = ${r} * inner;
+    inner = abs(inner) > 15.0 ? sign(inner) : tanh(inner);
+    inner = 0.5 * (1.0 + inner);
+    inner = x * inner;
+    return inner;
+` });
+e({
+	kernelName: "Gelu",
+	backendName: "webgl",
+	kernelFunc: a
+});
+var o = class {
+	variableNames = ["dy", "x"];
+	outputShape;
+	userCode;
+	constructor(e) {
+		this.outputShape = e, this.userCode = `
+            void main() {
+                float dy = getDyAtOutCoords();
+                float x  = getXAtOutCoords();
+                float x2 = x * x;
+                float x3 = x2 * x;
+                float u  = ${r} * (x + ${i} * x3);
+                float t = abs(u) > 15.0 ? sign(u) : tanh(u);
+                float sech2 = 1.0 - t * t;
+                float du_dx = ${r} * (1.0 + 3.0 * ${i} * x2);
+                float dgelu = 0.5 * (1.0 + t) + 0.5 * x * sech2 * du_dx;
+                setOutput(dy * dgelu);
+            }`;
+	}
+};
+function s(e) {
+	let { dy: t, x: n } = e.inputs, r = e.backend, i = new o(n.shape);
+	return r.runWebGLProgram(i, [t, n], "float32");
+}
+e({
+	kernelName: "GeluGrad",
+	backendName: "webgl",
+	kernelFunc: s
+});
+//#endregion
+export { a as gelu };

package/dist/ops/webgl/log.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+export {};

package/dist/ops/webgl/log.js

@@ -0,0 +1,14 @@
+import { Ii as e } from "../../dist-BewPQWjc.js";
+import { y as t } from "../../shared-DOgWaqvL.js";
+import { i as n, t as r } from "../../kernel_funcs_utils-HiXOOx3f.js";
+//#region lib/ops/webgl/log.ts
+e({
+	kernelName: "Log",
+	backendName: "webgl",
+	kernelFunc: n({
+		opSnippet: r + "\n  return x < 0.0 ? NAN : log(x);\n",
+		packedOpSnippet: "\n  vec4 result = log(x);\n  bvec4 isNaN = isnan(x);\n  result.r = isNaN.r ? x.r : (x.r < 0.0 ? NAN : result.r);\n  result.g = isNaN.g ? x.g : (x.g < 0.0 ? NAN : result.g);\n  result.b = isNaN.b ? x.b : (x.b < 0.0 ? NAN : result.b);\n  result.a = isNaN.a ? x.a : (x.a < 0.0 ? NAN : result.a);\n  return result;\n",
+		cpuKernelImpl: t
+	})
+});
+//#endregion

package/dist/ops/webgl/matMul16.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/ops/webgl/matMul16.js

@@ -0,0 +1,37 @@
+import { Ii as e, Wr as t, _n as n, br as r, gr as i, hn as a, lt as o, w as s } from "../../dist-BewPQWjc.js";
+import { isPackedTensor as c } from "../../utilities/packed.js";
+import { matMulMul as l } from "../matMulMul.js";
+import { matMulGelu as u } from "../matMulGelu.js";
+//#region lib/ops/webgl/matMul16.ts
+function d(e) {
+	let { A: d, B: f } = e.inputs, { transposeA: p, transposeB: m, scale: h, activation: g, scaleA: _, scaleB: v, forceOutputShape: y, perm: b } = e.attrs, x = !c(d), S = !c(f);
+	if (x && S) {
+		let e = _ === void 0 ? d : t(d, n(_)), c = v === void 0 ? f : t(f, n(v)), x;
+		if (h !== void 0) x = l(e, c, n(h), p, m);
+		else if (g === "gelu") x = u(e, c);
+		else if (g === "relu2") {
+			let t = i(e, c, p, m), n = o(t);
+			t.dispose(), x = a(n), n.dispose();
+		} else x = g === "relu" ? o(i(e, c, p, m)) : i(e, c, p, m);
+		if (b) if (y) {
+			let e = r(x, y);
+			x.dispose();
+			let t = s(e, b);
+			return e.dispose(), t;
+		} else {
+			let e = s(x, b);
+			return x.dispose(), e;
+		}
+		else if (y) {
+			let e = r(x, y);
+			return x.dispose(), e;
+		} else return x;
+	}
+	throw Error("Not implemented: matMul16 with packed inputs");
+}
+e({
+	kernelName: "MatMul16",
+	backendName: "webgl",
+	kernelFunc: d
+});
+//#endregion

package/dist/ops/webgl/matMulGelu.d.ts

@@ -0,0 +1,21 @@
+import { TensorInfo } from '@tensorflow/tfjs-core';
+import { MathBackendWebGL } from '@tensorflow/tfjs-backend-webgl';
+export declare const MATMUL_SHARED_DIM_THRESHOLD = 1000;
+interface BatchMatMulConfig {
+    a: TensorInfo;
+    b: TensorInfo;
+    transposeA: boolean;
+    transposeB: boolean;
+    backend: MathBackendWebGL;
+    activationSnippet?: string;
+    multiplier?: TensorInfo;
+}
+export declare function batchMatMulGeluImpl({ a, b, transposeA, transposeB, backend, activationSnippet, multiplier, }: BatchMatMulConfig): TensorInfo;
+export declare function batchMatMulKernel(args: {
+    inputs: {
+        x: TensorInfo;
+        kernel: TensorInfo;
+    };
+    backend: MathBackendWebGL;
+}): TensorInfo;
+export {};

package/dist/ops/webgl/matMulGelu.js

@@ -0,0 +1,2 @@
+import { n as e, r as t, t as n } from "../../matMulGelu-CPTntosE.js";
+export { n as MATMUL_SHARED_DIM_THRESHOLD, e as batchMatMulGeluImpl, t as batchMatMulKernel };

package/dist/ops/webgl/matMulMul.d.ts

@@ -0,0 +1,14 @@
+import { TensorInfo } from '@tensorflow/tfjs-core';
+import { MathBackendWebGL } from '@tensorflow/tfjs-backend-webgl';
+export declare function batchMatMulKernel(args: {
+    inputs: {
+        x: TensorInfo;
+        kernel: TensorInfo;
+        y: TensorInfo;
+    };
+    attrs: {
+        transposeA: boolean;
+        transposeB: boolean;
+    };
+    backend: MathBackendWebGL;
+}): TensorInfo;

package/dist/ops/webgl/matMulMul.js

@@ -0,0 +1,24 @@
+import { Ii as e } from "../../dist-BewPQWjc.js";
+import { n as t } from "../../matMulGelu-CPTntosE.js";
+//#region lib/ops/webgl/matMulMul.ts
+var n = "\n    return a * b;\n";
+function r(e) {
+	let { inputs: r, backend: i, attrs: a } = e, { x: o, kernel: s, y: c } = r, { transposeA: l, transposeB: u } = a;
+	if (o === void 0 || s === void 0) throw Error("BatchMatMul requires two input tensors.");
+	return t({
+		a: o,
+		b: s,
+		transposeA: l,
+		transposeB: u,
+		backend: i,
+		activationSnippet: n,
+		multiplier: c
+	});
+}
+e({
+	kernelName: "MatMulMul",
+	backendName: "webgl",
+	kernelFunc: r
+});
+//#endregion
+export { r as batchMatMulKernel };

package/dist/ops/webgl/mulDropout.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/ops/webgl/mulDropout.js

@@ -0,0 +1,32 @@
+import { Ii as e } from "../../dist-BewPQWjc.js";
+//#region lib/ops/webgl/mulDropout.ts
+var t = class {
+	variableNames = ["a", "b"];
+	outputShape;
+	userCode;
+	customUniforms = [{
+		name: "dropoutRate",
+		type: "float"
+	}, {
+		name: "seed",
+		type: "float"
+	}];
+	constructor(e, t, n) {
+		this.outputShape = [
+			e,
+			t,
+			n,
+			n
+		], this.userCode = "\n        float random(ivec4 coords) {\n            float x = float(coords.x * 4096 + coords.y * 256 + coords.z * 16 + coords.w);\n            return fract(sin(seed + x) * 43758.5453123);\n        }\n        void main() {\n            ivec4 coords = getOutputCoords();\n            float a = getA(coords.x, coords.y, coords.z, coords.w);\n            float b = getB(coords.x, coords.y, coords.z, coords.w);\n            \n            float keepProb = 1.0 - dropoutRate;\n            float rand = random(coords);\n            float mask = step(rand, keepProb);\n            setOutput(a * b * mask / keepProb);\n        }\n        ";
+	}
+};
+function n(e) {
+	let { inputs: n, attrs: r } = e, { a: i, b: a } = n, { dropoutRate: o, seed: s } = r, c = e.backend, l = i.shape[0], u = i.shape[2], d = i.shape[1], f = new t(l, d, u);
+	return c.runWebGLProgram(f, [i, a], "float32", [[o ?? 0], [s ?? Math.random() * 1e4]]);
+}
+e({
+	kernelName: "MulDropout",
+	backendName: "webgl",
+	kernelFunc: n
+});
+//#endregion

package/dist/ops/webgl/normRMS.d.ts

@@ -0,0 +1 @@
+export {};