@genai-fi/nanogpt 0.20.0 → 0.20.2

package/dist/ops/webgpu/attentionMask32_program.js

@@ -0,0 +1,62 @@
+import { s as e } from "../../webgpu_program-WOyIVMlZ.js";
+import { c as t, i as n } from "../../webgpu_util-B_F3SShA.js";
+//#region lib/ops/webgpu/attentionMask32_program.ts
+var r = class {
+	variableNames = ["q", "k"];
+	outputShape;
+	shaderKey = "AttentionMask";
+	dispatchLayout;
+	dispatch;
+	uniforms = "divisor: f32, pastLen: i32, inf: f32";
+	workgroupSize = [
+		64,
+		1,
+		1
+	];
+	size = !0;
+	hs;
+	nh;
+	T1;
+	T2;
+	constructor(e, r, i, a, o) {
+		if (this.shaderKey = `AttentionMask_${o}`, this.outputShape = [
+			e,
+			r,
+			i,
+			a
+		], this.hs = o, this.nh = r, this.T1 = i, this.T2 = a, this.dispatchLayout = t(this.outputShape), this.dispatch = n(this.dispatchLayout, this.outputShape, this.workgroupSize), o % 4 != 0) throw Error("Head size must be a multiple of 4 for AttentionMaskProgram");
+	}
+	getUserCode() {
+		return `
+            ${e("index")} {
+                
+                let coords = getCoordsFromIndex(index);
+                let b = coords[0];
+                let h = coords[1];
+                let t1 = coords[2];
+                let t2 = coords[3];
+
+                if (index < uniforms.size) {
+                    if (t2 > t1 + uniforms.pastLen) {
+                        setOutputAtIndex(index, uniforms.inf);
+                        return;
+                    }
+
+                    let q0 = getIndexFromCoords4D(vec4<i32>(b, h, t1, 0), uniforms.qShape);
+                    let k0 = getIndexFromCoords4D(vec4<i32>(b, h, t2, 0), uniforms.kShape);
+                    
+                    var sum: f32 = 0.0;
+                    for (var i: i32 = 0; i < ${this.hs}; i = i + 4) {
+                        let qv = vec4<f32>(q[q0 + i], q[q0 + i + 1], q[q0 + i + 2], q[q0 + i + 3]);
+                        let kv = vec4<f32>(k[k0 + i], k[k0 + i + 1], k[k0 + i + 2], k[k0 + i + 3]);
+                        sum = sum + dot(qv, kv);
+                    }
+                    let scaled = sum * uniforms.divisor;
+                    setOutputAtIndex(index, scaled);
+                }
+            }
+        `;
+	}
+};
+//#endregion
+export { r as default };

package/dist/ops/webgpu/clipScale.d.ts

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

package/dist/ops/webgpu/clipScale.js

@@ -0,0 +1,45 @@
+import { Ii as e } from "../../dist-BewPQWjc.js";
+import { ReduceProgram as t, reduce as n } from "./utils/reductions.js";
+import r from "./utils/deviceInfo.js";
+//#region lib/ops/webgpu/clipScale.ts
+var i = class extends t {
+	shaderKey = "clipscale";
+	constructor(e, t, n) {
+		super(e, t, {
+			reductionOp: "sum",
+			elementwise: !1,
+			forceWorkgroupSize: n
+		}, !1), this.uniforms += "scaling: f32, clipNorm: f32";
+	}
+	getReadSnippet() {
+		return "\n            return bitcast<f32>(u32(x[index]));\n        ";
+	}
+	getWriteSnippet() {
+		return "\n            if (tid == 0) {\n                let cnorm = uniforms.clipNorm;\n                let gradNorm = sqrt(max(bestValue, 0.0));\n                result[0] = (cnorm / max(cnorm, gradNorm)) * uniforms.scaling;\n                result[1] = gradNorm;\n            }\n        ";
+	}
+};
+function a(e) {
+	let { x: t } = e.inputs, { invLossScaling: a, clipNorm: o } = e.attrs, s = e.backend, c = [];
+	if (t.shape.length !== 1) throw Error(`ClipScaleProgram requires 1D input, but got shape ${t.shape}`);
+	let l = r(s), u = 128, d = 1, f = t.shape[0];
+	f <= 16 ? u = 16 : f <= 32 ? u = 32 : f <= 64 && (u = 64), f > 128 && (d = Math.ceil(f / 128));
+	let p = n(new i(l, {
+		inSize: u * d,
+		outSize: 2,
+		batchSize: 1,
+		windowSize: u
+	}, u), [t], s, [{
+		type: "float32",
+		data: [a]
+	}, {
+		type: "float32",
+		data: [o]
+	}]);
+	return c.forEach((e) => e.dispose()), p;
+}
+e({
+	kernelName: "ClipScale",
+	backendName: "webgpu",
+	kernelFunc: a
+});
+//#endregion

package/dist/ops/webgpu/concat16.d.ts

@@ -0,0 +1,19 @@
+import { KernelConfig } from '@tensorflow/tfjs-core';
+import { WebGPUProgram } from '@tensorflow/tfjs-backend-webgpu/dist/webgpu_program';
+export declare class ConcatProgram implements WebGPUProgram {
+    outputShape: number[];
+    shaderKey: string;
+    dispatchLayout: {
+        x: number[];
+    };
+    dispatch: [number, number, number];
+    variableNames: string[];
+    uniforms: string;
+    workPerThread: number;
+    workgroupSize: [number, number, number];
+    size: boolean;
+    offsetLength: number;
+    constructor(shapes: [number, number][]);
+    getUserCode(): string;
+}
+export declare const concatConfig: KernelConfig;

package/dist/ops/webgpu/concat16.js

@@ -0,0 +1,111 @@
+import { Ii as e, nc as t, oc as n } from "../../dist-BewPQWjc.js";
+import { n as r, t as i } from "../../concat_util-CWDZCBlA.js";
+import { s as a } from "../../webgpu_program-WOyIVMlZ.js";
+import { c as o, i as s } from "../../webgpu_util-B_F3SShA.js";
+import { t as c } from "../../Reshape-DqO3r8BC.js";
+//#region lib/ops/webgpu/concat16.ts
+var l = class {
+	outputShape;
+	shaderKey;
+	dispatchLayout;
+	dispatch;
+	variableNames;
+	uniforms = "";
+	workPerThread = 1;
+	workgroupSize = [
+		64,
+		1,
+		1
+	];
+	size = !0;
+	offsetLength;
+	constructor(e) {
+		this.outputShape = r(e, 1), this.variableNames = e.map((e, t) => `T${t}`), this.dispatchLayout = o(this.outputShape), this.dispatch = s(this.dispatchLayout, this.outputShape, this.workgroupSize, [
+			this.workPerThread,
+			1,
+			1
+		]), this.offsetLength = e.length - 1;
+		for (let e = 0; e < this.offsetLength; e++) this.uniforms += `offset${e} : i32,`;
+		this.shaderKey = "concat16";
+	}
+	getUserCode() {
+		let e = [];
+		if (this.offsetLength > 0) {
+			e.push("if (yC < uniforms.offset0){ result[getIndexFromCoords2D(coords, uniforms.outShape)] = T0[getIndexFromCoords2D(vec2<i32>(yR, yC), uniforms.t0Shape)]; }");
+			for (let t = 1; t < this.offsetLength; t++) e.push(`else if (yC < uniforms.offset${[t]}){ result[getIndexFromCoords2D(coords, uniforms.outShape)] = T${t}[getIndexFromCoords2D(vec2<i32>(yR, yC - uniforms.offset${t - 1}), uniforms.t${t}Shape)]; }`);
+			let t = this.offsetLength, n = this.offsetLength - 1;
+			e.push(`else { result[getIndexFromCoords2D(coords, uniforms.outShape)] = T${t}[getIndexFromCoords2D(vec2<i32>(yR, yC - uniforms.offset${n}), uniforms.t${t}Shape)]; }`);
+		} else e.push("result[getIndexFromCoords2D(coords, uniforms.outShape)] = T0[getIndexFromCoords2D(vec2<i32>(yR, yC), uniforms.t0Shape)];");
+		return `
+      ${a("index")} {
+        for(var i = 0; i < ${this.workPerThread}; i = i + 1) {
+          let flatIndex = index * ${this.workPerThread} + i;
+          if(flatIndex < uniforms.size) {
+            let coords = getCoordsFromIndex(flatIndex);
+            let yR = coords.x;
+            let yC = coords.y;
+
+            ${e.join("\n        ")}
+          }
+        }
+      }
+    `;
+	}
+};
+function u(e, t, n) {
+	let r = n.device.limits.maxStorageBuffersPerShaderStage - 1;
+	if (e.length > r) {
+		let i = [];
+		for (let a = 0; a < e.length; a += r) {
+			let o = e.slice(a, a + r);
+			i.push(u(o, t, n));
+		}
+		let a = u(i, t, n);
+		for (let e of i) n.disposeData(e.dataId);
+		return a;
+	}
+	let { tensors2D: i, outShape: a } = d(e, t, n), o = i.map((e) => e.shape), s = new l(o), f = [], p = Array(o.length - 1);
+	if (p.length > 0) {
+		p[0] = o[0][1], f.push({
+			type: "int32",
+			data: [p[0]]
+		});
+		for (let e = 1; e < p.length; e++) p[e] = p[e - 1] + o[e][1], f.push({
+			type: "int32",
+			data: [p[e]]
+		});
+	}
+	let m = n.runWebGPUProgram(s, i, i[0].dtype, f);
+	i.forEach((e) => n.disposeData(e.dataId));
+	let h = c({
+		inputs: { x: m },
+		backend: n,
+		attrs: { shape: a }
+	});
+	return n.disposeData(m.dataId), h;
+}
+function d(e, t, i) {
+	let a = r(e.map((e) => e.shape), t);
+	return {
+		tensors2D: e.map((e) => c({
+			inputs: { x: e },
+			backend: i,
+			attrs: { shape: [n(e.shape.slice(0, t)), n(e.shape.slice(t))] }
+		})),
+		outShape: a
+	};
+}
+function f(e) {
+	let { inputs: a, backend: o, attrs: s } = e, { axis: c } = s, l = t(c, a[0].shape)[0];
+	i(a.map((e) => e.shape), l);
+	let d = r(a.map((e) => e.shape), l);
+	return n(d) === 0 ? o.makeTensorInfo(d, a[0].dtype, []) : u(a.filter((e) => n(e.shape) > 0), l, o);
+}
+var p = {
+	kernelName: "Concat16",
+	backendName: "webgpu",
+	kernelFunc: f
+};
+e(p);
+//#endregion
+export { l as ConcatProgram, p as concatConfig };

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

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

package/dist/ops/webgpu/dropout16.js

@@ -0,0 +1,59 @@
+import { Ii as e } from "../../dist-BewPQWjc.js";
+import { s as t } from "../../webgpu_program-WOyIVMlZ.js";
+import { c as n, i as r } from "../../webgpu_util-B_F3SShA.js";
+//#region lib/ops/webgpu/dropout16.ts
+var i = class {
+	variableNames = ["x"];
+	outputShape;
+	shaderKey = "Dropout16";
+	dispatchLayout;
+	dispatch;
+	workgroupSize = [
+		64,
+		1,
+		1
+	];
+	size = !0;
+	uniforms = "dropout: f32, seed: f32";
+	constructor(e) {
+		this.shaderKey = "Dropout16", this.outputShape = e, this.dispatchLayout = n(this.outputShape), this.dispatch = r(this.dispatchLayout, this.outputShape, this.workgroupSize);
+	}
+	getUserCode() {
+		return `
+
+        fn random(coords: vec3<i32>) -> vec2<f32> {
+            let x1 = f32(coords.x * 4096 + coords.y * 256 + coords.z * 2 * 16);
+            let x2 = f32(coords.x * 4096 + coords.y * 256 + (coords.z * 2 + 1) * 16);
+            return vec2<f32>(fract(sin(uniforms.seed + x1) * 43758.5453123), fract(sin(uniforms.seed + x2) * 43758.5453123));
+        }
+
+        ${t("index")} {
+            if (index < uniforms.size) {
+                let coords = getCoordsFromIndex(index);
+                let values = unpack2x16float(u32(x[index]));
+                let keepProb = 1.0 - uniforms.dropout;
+                let rand = random(coords);
+                let mask = step(rand, vec2<f32>(keepProb));
+                let outVal = values * mask / keepProb;
+                result[index] = i32(pack2x16float(outVal));
+            }
+        }
+        `;
+	}
+};
+function a(e) {
+	let { x: t } = e.inputs, { dropout: n, seed: r } = e.attrs, a = e.backend, o = new i(t.shape), s = [{
+		type: "float32",
+		data: [n]
+	}, {
+		type: "float32",
+		data: [r]
+	}];
+	return a.runWebGPUProgram(o, [t], "packedF16", s);
+}
+e({
+	kernelName: "Dropout16",
+	backendName: "webgpu",
+	kernelFunc: a
+});
+//#endregion

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

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

package/dist/ops/webgpu/gatherSub.js

@@ -0,0 +1,52 @@
+import { Fs as e, Ii as t } from "../../dist-BewPQWjc.js";
+import { s as n } from "../../webgpu_program-WOyIVMlZ.js";
+import { c as r, i } from "../../webgpu_util-B_F3SShA.js";
+//#region lib/ops/webgpu/gatherSub.ts
+var a = class {
+	variableNames = [
+		"labels",
+		"logits",
+		"values"
+	];
+	outputShape;
+	shaderKey = "GatherSub";
+	dispatchLayout;
+	dispatch;
+	workgroupSize = [
+		64,
+		1,
+		1
+	];
+	size = !0;
+	constructor(e) {
+		this.outputShape = [e], this.dispatchLayout = r(this.outputShape), this.dispatch = i(this.dispatchLayout, this.outputShape, this.workgroupSize);
+	}
+	getUserCode() {
+		return `
+        ${n("index")} {
+            if (index < uniforms.size) {
+                let idx = i32(labels[index]);
+                let val = values[index];
+                let logit = logits[index * uniforms.logitsShape[1] + idx];
+                setOutputAtIndex(index, val - logit);
+            }
+        }
+    `;
+	}
+};
+function o(t) {
+	let { logits: n, labels: r, values: i } = t.inputs, o = t.backend, s = r.shape[0];
+	e(i.shape, [s], "Error in EfficientGatherSub: "), e(r.shape, [s], "Error in EfficientGatherSub: ");
+	let c = new a(s);
+	return o.runWebGPUProgram(c, [
+		r,
+		n,
+		i
+	], "float32");
+}
+t({
+	kernelName: "EfficientGatherSub",
+	backendName: "webgpu",
+	kernelFunc: o
+});
+//#endregion

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

@@ -0,0 +1,14 @@
+import { WebGPUProgram } from '@tensorflow/tfjs-backend-webgpu';
+export declare class GeluProgram implements WebGPUProgram {
+    outputShape: number[];
+    shaderKey: string;
+    dispatchLayout: {
+        x: number[];
+    };
+    dispatch: [number, number, number];
+    variableNames: string[];
+    workgroupSize: [number, number, number];
+    size: boolean;
+    constructor(outputShape: number[]);
+    getUserCode(): string;
+}

package/dist/ops/webgpu/gelu.js

@@ -0,0 +1,147 @@
+import { Ii as e } from "../../dist-BewPQWjc.js";
+import { isPackedTensor as t } from "../../utilities/packed.js";
+import { s as n } from "../../webgpu_program-WOyIVMlZ.js";
+import { c as r, i } from "../../webgpu_util-B_F3SShA.js";
+//#region lib/ops/webgpu/gelu.ts
+var a = .7978845608028654, o = .044715, s = class {
+	outputShape;
+	shaderKey;
+	dispatchLayout;
+	dispatch;
+	variableNames = ["A"];
+	workgroupSize;
+	size = !0;
+	constructor(e) {
+		this.workgroupSize = [
+			128,
+			1,
+			1
+		], this.outputShape = e, this.dispatchLayout = r(this.outputShape), this.dispatch = i(this.dispatchLayout, this.outputShape, this.workgroupSize), this.shaderKey = "unary_gelu";
+	}
+	getUserCode() {
+		return `
+            // TODO: revisit after https://github.com/gpuweb/gpuweb/issues/4458 is resolved
+            fn tanhComplete(x: f32) -> f32 {
+                return select(tanh(x), sign(x), abs(x) > 15.0);
+            }
+            fn unaryOperation(x : f32) -> f32 {
+                let x3 = x * x * x;
+                var inner = fma(${o}, x3, x);
+                inner = ${a} * inner;
+                inner = tanhComplete(inner);
+                inner = 0.5 * (1.0 + inner);
+                return x * inner;
+            }
+            ${n("index")} {
+                if (index < uniforms.size) {
+                let a = getAByOutputIndex(index);
+                setOutputAtIndex(index, unaryOperation(a));
+                }
+            }
+      `;
+	}
+};
+function c(e) {
+	let { x: t } = e.inputs, n = e.backend, r = new s(t.shape);
+	return n.runWebGPUProgram(r, [t], "float32");
+}
+e({
+	kernelName: "Gelu",
+	backendName: "webgpu",
+	kernelFunc: c
+});
+var l = class {
+	variableNames = ["dy", "x"];
+	outputShape;
+	shaderKey = "GeluGrad";
+	dispatchLayout;
+	dispatch;
+	workgroupSize = [
+		128,
+		1,
+		1
+	];
+	size = !0;
+	constructor(e) {
+		this.outputShape = e, this.dispatchLayout = r(this.outputShape), this.dispatch = i(this.dispatchLayout, this.outputShape, this.workgroupSize);
+	}
+	getUserCode() {
+		return `
+            // TODO: revisit after https://github.com/gpuweb/gpuweb/issues/4458 is resolved
+            fn tanhComplete(x: f32) -> f32 {
+                return select(tanh(x), sign(x), abs(x) > 15.0);
+            }
+            fn activationGrad(dy: f32, X: f32) -> f32 {
+                let x2 = X * X;
+                let x3 = x2 * X;
+                let u  = ${a} * (X + ${o} * x3);
+                let t  = tanhComplete(u);
+                let sech2 = 1.0 - t * t;
+                let du_dx = ${a} * (1.0 + 3.0 * ${o} * x2);
+                let dgelu = 0.5 * (1.0 + t) + 0.5 * X * sech2 * du_dx;
+                return dy *dgelu;
+            }
+            ${n("index")} {
+                if (index < uniforms.size) {
+                    let X  = unpack2x16float(u32(x[index]));
+                    let DY = unpack2x16float(u32(dy[index]));
+                    let dgelu = vec2<f32>(
+                        activationGrad(DY.x, X.x),
+                        activationGrad(DY.y, X.y)
+                    );
+                    result[index] = i32(pack2x16float(dgelu));
+                }
+            }`;
+	}
+}, u = class {
+	variableNames = ["dy", "x"];
+	outputShape;
+	shaderKey = "GeluGrad";
+	dispatchLayout;
+	dispatch;
+	workgroupSize = [
+		128,
+		1,
+		1
+	];
+	size = !0;
+	constructor(e) {
+		this.outputShape = e, this.dispatchLayout = r(this.outputShape), this.dispatch = i(this.dispatchLayout, this.outputShape, this.workgroupSize);
+	}
+	getUserCode() {
+		return `
+            // TODO: revisit after https://github.com/gpuweb/gpuweb/issues/4458 is resolved
+            fn tanhComplete(x: f32) -> f32 {
+                return select(tanh(x), sign(x), abs(x) > 15.0);
+            }
+            fn activationGrad(dy: f32, X: f32) -> f32 {
+                let x2 = X * X;
+                let x3 = x2 * X;
+                let u  = ${a} * (X + ${o} * x3);
+                let t  = tanhComplete(u);
+                let sech2 = 1.0 - t * t;
+                let du_dx = ${a} * (1.0 + 3.0 * ${o} * x2);
+                let dgelu = 0.5 * (1.0 + t) + 0.5 * X * sech2 * du_dx;
+                return dy *dgelu;
+            }
+            ${n("index")} {
+                if (index < uniforms.size) {
+                    let X  = getXByOutputIndex(index);
+                    let DY = getDyByOutputIndex(index);
+                    let dgelu = activationGrad(DY, X);
+                    setOutputAtIndex(index, dgelu);
+                }
+            }`;
+	}
+};
+function d(e) {
+	let { dy: n, x: r } = e.inputs, i = e.backend, a = t(n), o = a ? new l(r.shape) : new u(r.shape);
+	return i.runWebGPUProgram(o, [n, r], a ? "packedF16" : "float32");
+}
+e({
+	kernelName: "GeluGrad",
+	backendName: "webgpu",
+	kernelFunc: d
+});
+//#endregion
+export { s as GeluProgram };

package/dist/ops/webgpu/index.js

@@ -0,0 +1,26 @@
+import "./unpack16.js";
+import "./transpose16.js";
+import "./sum16.js";
+import "./sub16.js";
+import "./softmax16grad.js";
+import "./softmax16.js";
+import "./slice16.js";
+import "./scatterSub.js";
+import "./rope.js";
+import "./qkv.js";
+import "./pack16.js";
+import "./normRMSGrad.js";
+import "./normRMS.js";
+import "./norm2.js";
+import "./mul16.js";
+import "./matMul16.js";
+import "./attentionMask.js";
+import "./appendCache.js";
+import "./gatherSub.js";
+import "./gelu.js";
+import "./adamMoments.js";
+import "./adamAdjust.js";
+import "./add16.js";
+import "./concat16.js";
+import "./clipScale.js";
+import "./dropout16.js";

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

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

package/dist/ops/webgpu/matMul16.js

@@ -0,0 +1,70 @@
+import { Ii as e, In as t, Wr as n, _n as r, br as i, gr as a, hn as o, lt as s, oc as c, w as l } from "../../dist-BewPQWjc.js";
+import { isPackedTensor as u } from "../../utilities/packed.js";
+import { reshape16 as d } from "../reshape16.js";
+import { matMulMul as f } from "../matMulMul.js";
+import { matMulGelu as p } from "../matMulGelu.js";
+import m from "./matMul16_program.js";
+//#region lib/ops/webgpu/matMul16.ts
+function h(e) {
+	let { A: h, B: g } = e.inputs, { transposeA: _, transposeB: v, scale: y, activation: b, scaleA: x, scaleB: S, forceOutputShape: C, perm: w, causalMask: T, pastLen: E } = e.attrs, D = e.backend, O = !u(h), k = !u(g);
+	if (O && k) {
+		let e = x === void 0 ? h : n(h, r(x)), t = S === void 0 ? g : n(g, r(S));
+		if (T) throw Error("Causal mask is not supported for unpacked MatMul16.");
+		let c;
+		if (y !== void 0) c = f(e, t, r(y), _, v);
+		else if (b === "gelu") c = p(e, t);
+		else if (b === "relu2") {
+			let n = a(e, t, _, v), r = s(n);
+			n.dispose(), c = o(r), r.dispose();
+		} else c = b === "relu" ? s(a(e, t, _, v)) : a(e, t, _, v);
+		if (w) if (C) {
+			let e = i(c, C);
+			c.dispose();
+			let t = l(e, w);
+			return e.dispose(), t;
+		} else {
+			let e = l(c, w);
+			return c.dispose(), e;
+		}
+		else if (C) {
+			let e = i(c, C);
+			return c.dispose(), e;
+		} else return c;
+	}
+	if (O && !k) throw Error("When using mixed precision, A must be packed if B is packed.");
+	if (!O && k) throw Error("When using mixed precision, B must be packed if A is packed.");
+	let A = h.shape.length, j = g.shape.length, M = h.shape.slice(0, -2), N = g.shape.slice(0, -2), P = c(M), F = c(N), I = t(h.shape.slice(0, -2), g.shape.slice(0, -2)), L = Math.max(P, F), R = h.shape[A - 2], z = g.shape[j - 2], B = h.shape[A - 1] * 2, V = g.shape[j - 1] * 2, H = d(h, [
+		P,
+		h.shape[A - 2],
+		h.shape[A - 1]
+	]), U = d(g, [
+		F,
+		g.shape[j - 2],
+		g.shape[j - 1]
+	]), W = new m(L, R, z, B, V, _, v), G = [];
+	y !== void 0 && (W.useScale(), G.push({
+		type: "float32",
+		data: [y]
+	})), x !== void 0 && (W.useScaleA(), G.push({
+		type: "float32",
+		data: [x]
+	})), S !== void 0 && (W.useScaleB(), G.push({
+		type: "float32",
+		data: [S]
+	})), b !== void 0 && W.useActivation(b), T && (W.useCausalMask(), G.push({
+		type: "int32",
+		data: [E || 0]
+	}));
+	let K = W.outputShape.length;
+	C && (e.attrs.originalShape = W.outputShape);
+	let q = C ?? I.concat([W.outputShape[K - 2], W.outputShape[K - 1]]);
+	W.setOutputShape(q, w);
+	let J = D.runWebGPUProgram(W, [H, U], "packedF16", G.length > 0 ? G : void 0);
+	return H.dispose(), U.dispose(), J;
+}
+e({
+	kernelName: "MatMul16",
+	backendName: "webgpu",
+	kernelFunc: h
+});
+//#endregion

package/dist/ops/webgpu/matMul16_program.d.ts

@@ -0,0 +1,42 @@
+import { WebGPUProgram } from '@tensorflow/tfjs-backend-webgpu';
+export default class MatMul16ProgramGeneric implements WebGPUProgram {
+    variableNames: string[];
+    outputShape: number[];
+    shaderKey: string;
+    dispatchLayout: {
+        x: number[];
+        y: number[];
+        z: number[];
+    };
+    dispatch: [number, number, number];
+    workgroupSize: [number, number, number];
+    dimInner: number;
+    transposeA: boolean;
+    transposeB: boolean;
+    broadcastBatch: boolean;
+    tileInner: number;
+    uniforms?: string;
+    scale: boolean;
+    scaleA: boolean;
+    scaleB: boolean;
+    activation?: 'gelu' | 'relu2' | 'relu';
+    causalMask: boolean;
+    outputComponent?: number | undefined;
+    variableComponents?: number[];
+    outputIndexSnippet?: string;
+    outputStrideSnippet?: string;
+    constructor(batch: number, O1: number, O2: number, I1: number, I2: number, transposeA?: boolean, transposeB?: boolean);
+    private addUniform;
+    setOutputShape(shape: number[], perm?: number[]): void;
+    useScale(): void;
+    useScaleA(): void;
+    useScaleB(): void;
+    useActivation(activation: 'gelu' | 'relu2' | 'relu'): void;
+    useCausalMask(): void;
+    private activationSnippet;
+    private readASnippet;
+    private readBSnippet;
+    private baseIndexSnippets;
+    private offsetSnippets;
+    getUserCode(): string;
+}