@genai-fi/nanogpt 0.9.0 → 0.10.0

package/dist/ops-CNI3TwqM.js

@@ -0,0 +1,645 @@
+import { A as f, B as c, E as d, j as B, S as A, o as ls, p as Ns, b as y, T as bs, J as Is, G as D, m as b, n as O, l as S, i as Ss, c as g, D as Q, d as Ts, w as Ms } from "./index-ZyQhjEPo.js";
+import { ag as As, ah as ws, ai as qs, aj as Ds, m as v, ak as Bs, al as xs, am as Gs, an as Os, ao as Ls, ap as zs, aq as Rs, ar as Ws, as as vs, at as Cs, au as Ks, av as Vs, aw as js, ax as Ps, ay as Ys, az as Fs, aA as Us, aB as Zs, aC as Hs, aD as Js, aE as Xs } from "./tensor_util-DV-FP5Q3.js";
+import { a as p, p as Qs, j as L } from "./tensor-DdQUJZlz.js";
+import { t as U } from "./tile-BzyEiF-F.js";
+import { e as W } from "./expand_dims-BPG4fwBP.js";
+import { t as q } from "./tensor1d-CeZuc-Rv.js";
+import { n as sn, a as nn, b as en } from "./non_max_suppression_impl-B2W7YjZB.js";
+import { r as I } from "./reshape-DevtBWtf.js";
+import { s as ds } from "./split-DrfihRpZ.js";
+import { s as E } from "./sum-_fzj5ZTB.js";
+import { b as ss } from "./broadcast_to-CwF7XIeu.js";
+import { s as M } from "./slice-D_gkkqZK.js";
+import { r as Z } from "./range-BMS52eQi.js";
+import { t as tn } from "./tensor-f35l8Odg.js";
+import { n as j, t as us } from "./transpose-DKELTqhe.js";
+import { s as H } from "./stack-yOIAalTq.js";
+import { z as rn } from "./zeros-2gldETuK.js";
+import { e as gs } from "./axis_util-BvHEw88j.js";
+import { m as ns, a as ps, e as rs, l as on } from "./log_sum_exp-DWI-76TI.js";
+import { s as an } from "./squeeze-DZEpeblb.js";
+import { c as es } from "./concat-BHlIJeyT.js";
+import { m as G } from "./mat_mul-DeAh4uTH.js";
+import { t as ts } from "./tensor2d-G4Ys2GxX.js";
+import { o as cn } from "./ones-CAMiP4I2.js";
+import { r as $s } from "./relu-yZ2-7WxU.js";
+function ln(e, r, s) {
+  const t = c(e, "x", "bincount"), n = c(r, "weights", "bincount");
+  p(t.dtype === "int32", () => `Error in bincount: input dtype must be int32, but got ${t.dtype}`), p(s >= 0, () => `size must be non-negative, but got ${s}.`), p(n.size === t.size || n.size === 0, () => `Error in bincount: weights must have the same size as input or0-length, but got input shape: ${t.shape}, weights shape: ${n.shape}.`);
+  const o = { x: t, weights: n }, a = { size: s };
+  return d.runKernel(As, o, a);
+}
+const un = /* @__PURE__ */ f({ bincount_: ln });
+function pn(e, r, s) {
+  const t = c(r, "a", "where"), n = c(s, "b", "where"), o = c(e, "condition", "where", "bool"), a = B(B(o.shape, t.shape), n.shape), i = ss(o, a), u = ss(t, a), l = ss(n, a), m = {
+    condition: i,
+    t: u,
+    e: l
+  };
+  return d.runKernel(ws, m);
+}
+const C = /* @__PURE__ */ f({ where_: pn });
+function fn(e, ...r) {
+  const s = r.map((n, o) => c(n, `tensors${o}`, "einsum")), t = { equation: e };
+  return d.runKernel(qs, s, t);
+}
+const V = /* @__PURE__ */ f({ einsum_: fn });
+function mn(e, r = null, s = !1) {
+  const n = { x: c(e, "x", "min") }, o = { axis: r, keepDims: s };
+  return d.runKernel(Ds, n, o);
+}
+const fs = /* @__PURE__ */ f({ min_: mn });
+function hn(e, r = "euclidean", s = null, t = !1) {
+  e = c(e, "x", "norm");
+  const n = Es(e, r, s);
+  let o = n.shape;
+  if (t) {
+    const a = Qs(s, e.shape);
+    o = gs(n.shape, a);
+  }
+  return I(n, o);
+}
+function Es(e, r, s = null) {
+  if (e.rank === 0)
+    return A(e);
+  if (e.rank !== 1 && s === null)
+    return Es(I(e, [-1]), r, s);
+  if (e.rank === 1 || typeof s == "number" || Array.isArray(s) && s.length === 1) {
+    if (r === 1)
+      return E(A(e), s);
+    if (r === 1 / 0)
+      return ns(A(e), s);
+    if (r === -1 / 0)
+      return fs(A(e), s);
+    if (r === "euclidean" || r === 2)
+      return ls(E(Ns(A(e), y(2, "int32")), s));
+    throw new Error(`Error in norm: invalid ord value: ${r}`);
+  }
+  if (Array.isArray(s) && s.length === 2) {
+    if (r === 1)
+      return ns(E(A(e), s[0]), s[1] - 1);
+    if (r === 1 / 0)
+      return ns(E(A(e), s[1]), s[0]);
+    if (r === -1 / 0)
+      return fs(E(A(e), s[1]), s[0]);
+    if (r === "fro" || r === "euclidean")
+      return ls(E(bs(e), s));
+    throw new Error(`Error in norm: invalid ord value: ${r}`);
+  }
+  throw new Error(`Error in norm: invalid axis: ${s}`);
+}
+const _s = /* @__PURE__ */ f({ norm_: hn });
+function bn(e, r, s, t = "float32") {
+  r == null && (r = e);
+  const n = Is([e, r], t), o = e <= r ? e : r;
+  for (let i = 0; i < o; ++i)
+    n.set(1, i, i);
+  const a = I(n.toTensor(), [e, r]);
+  if (s == null)
+    return a;
+  if (s.length === 1)
+    return U(W(a, 0), [s[0], 1, 1]);
+  if (s.length === 2)
+    return U(W(W(a, 0), 0), [s[0], s[1], 1, 1]);
+  if (s.length === 3)
+    return U(W(W(W(a, 0), 0), 0), [
+      s[0],
+      s[1],
+      s[2],
+      1,
+      1
+    ]);
+  throw new Error(`eye() currently supports only 1D and 2D batchShapes, but received ${s.length}D.`);
+}
+const dn = /* @__PURE__ */ f({ eye_: bn });
+function gn(e, r) {
+  let s = c(e, "a", "greater", "string_or_numeric"), t = c(r, "b", "greater", "string_or_numeric");
+  [s, t] = v(s, t), B(s.shape, t.shape);
+  const n = { a: s, b: t };
+  return d.runKernel(Bs, n);
+}
+const as = /* @__PURE__ */ f({ greater_: gn });
+function $n(e, r) {
+  let s = c(e, "a", "greaterEqual", "string_or_numeric"), t = c(r, "b", "greaterEqual", "string_or_numeric");
+  [s, t] = v(s, t), B(s.shape, t.shape);
+  const n = { a: s, b: t };
+  return d.runKernel(xs, n);
+}
+const En = /* @__PURE__ */ f({ greaterEqual_: $n });
+function _n(e, r) {
+  let s = c(e, "a", "less", "string_or_numeric"), t = c(r, "b", "less", "string_or_numeric");
+  [s, t] = v(s, t), B(s.shape, t.shape);
+  const n = { a: s, b: t };
+  return d.runKernel(Gs, n);
+}
+const ms = /* @__PURE__ */ f({ less_: _n });
+function yn(e, r) {
+  let s = c(e, "a", "lessEqual", "string_or_numeric"), t = c(r, "b", "lessEqual", "string_or_numeric");
+  [s, t] = v(s, t), B(s.shape, t.shape);
+  const n = { a: s, b: t };
+  return d.runKernel(Os, n);
+}
+const ys = /* @__PURE__ */ f({ lessEqual_: yn });
+function kn(e) {
+  const s = { x: c(e, "x", "log1p") };
+  return d.runKernel(Ls, s);
+}
+const Nn = /* @__PURE__ */ f({ log1p_: kn });
+function In(e, r) {
+  const s = c(e, "a", "logicalAnd", "bool"), t = c(r, "b", "logicalAnd", "bool");
+  B(s.shape, t.shape);
+  const n = { a: s, b: t };
+  return d.runKernel(zs, n);
+}
+const Sn = /* @__PURE__ */ f({ logicalAnd_: In });
+function Tn(e, r = null, s = !1) {
+  const n = { x: c(e, "x", "mean") }, o = { axis: r, keepDims: s };
+  return d.runKernel(Rs, n, o);
+}
+const Mn = /* @__PURE__ */ f({ mean_: Tn });
+function An(e, r) {
+  let s = c(e, "a", "minimum"), t = c(r, "b", "minimum");
+  [s, t] = v(s, t), s.dtype === "bool" && (s = D(s, "int32"), t = D(t, "int32")), B(s.shape, t.shape);
+  const n = { a: s, b: t };
+  return d.runKernel(Ws, n);
+}
+const os = /* @__PURE__ */ f({ minimum_: An });
+function wn(e, r) {
+  let s = c(e, "a", "notEqual", "string_or_numeric"), t = c(r, "b", "notEqual", "string_or_numeric");
+  [s, t] = v(s, t), B(s.shape, t.shape);
+  const n = { a: s, b: t };
+  return d.runKernel(vs, n);
+}
+const qn = /* @__PURE__ */ f({ notEqual_: wn });
+function Dn(e) {
+  const s = { x: c(e, "x", "round") };
+  return d.runKernel(Cs, s);
+}
+const Bn = /* @__PURE__ */ f({ round_: Dn });
+function xn(e, r) {
+  let s = c(e, "a", "squaredDifference"), t = c(r, "b", "squaredDifference");
+  [s, t] = v(s, t), B(s.shape, t.shape);
+  const n = { a: s, b: t }, o = {};
+  return d.runKernel(Ks, n, o);
+}
+const Gn = /* @__PURE__ */ f({ squaredDifference_: xn });
+function On(e, r = 0) {
+  const s = c(e, "x", "unstack", "string_or_numeric");
+  p(r >= -s.shape.length && r < s.shape.length, () => `Axis = ${r} is not in [-${s.shape.length}, ${s.shape.length})`);
+  const t = { value: s }, n = { axis: r };
+  return d.runKernel(Vs, t, n);
+}
+const ks = /* @__PURE__ */ f({ unstack_: On });
+function Ln(e, r, s, t, n = "bilinear", o = 0) {
+  const a = c(e, "image", "cropAndResize"), i = c(r, "boxes", "cropAndResize", "float32"), u = c(s, "boxInd", "cropAndResize", "int32"), l = i.shape[0];
+  p(a.rank === 4, () => `Error in cropAndResize: image must be rank 4,but got rank ${a.rank}.`), p(i.rank === 2 && i.shape[1] === 4, () => `Error in cropAndResize: boxes must be have size [${l},4] but had shape ${i.shape}.`), p(u.rank === 1 && u.shape[0] === l, () => `Error in cropAndResize: boxInd must be have size [${l}] but had shape ${i.shape}.`), p(t.length === 2, () => `Error in cropAndResize: cropSize must be of length 2, but got length ${t.length}.`), p(t[0] >= 1 && t[1] >= 1, () => `cropSize must be atleast [1,1], but was ${t}`), p(n === "bilinear" || n === "nearest", () => `method must be bilinear or nearest, but was ${n}`);
+  const m = { image: a, boxes: i, boxInd: u }, h = { method: n, extrapolationValue: o, cropSize: t };
+  return d.runKernel(js, m, h);
+}
+const zn = /* @__PURE__ */ f({ cropAndResize_: Ln });
+function Rn(e) {
+  const r = c(e, "image", "flipLeftRight", "float32");
+  p(r.rank === 4, () => `Error in flipLeftRight: image must be rank 4,but got rank ${r.rank}.`);
+  const s = { image: r };
+  return d.runKernel(Ps, s, {});
+}
+const Wn = /* @__PURE__ */ f({ flipLeftRight_: Rn });
+function vn(e) {
+  const r = c(e, "image", "grayscaleToRGB"), s = r.rank - 1, t = r.shape[s];
+  p(r.rank >= 2, () => `Error in grayscaleToRGB: images must be at least rank 2, but got rank ${r.rank}.`), p(t === 1, () => `Error in grayscaleToRGB: last dimension of a grayscale image should be size 1, but got size ${t}.`);
+  const n = new Array(r.rank);
+  return n.fill(1, 0, s), n[s] = 3, U(r, n);
+}
+const Cn = /* @__PURE__ */ f({ grayscaleToRGB_: vn });
+function Kn(e) {
+  const r = c(e, "image", "RGBToGrayscale"), s = r.rank - 1, t = r.shape[s];
+  p(r.rank >= 2, () => `Error in RGBToGrayscale: images must be at least rank 2, but got rank ${r.rank}.`), p(t === 3, () => `Error in RGBToGrayscale: last dimension of an RGB image should be size 3, but got size ${t}.`);
+  const n = r.dtype, o = D(r, "float32"), a = q([0.2989, 0.587, 0.114]);
+  let i;
+  switch (r.rank) {
+    case 2:
+      i = V("ij,j->i", o, a);
+      break;
+    case 3:
+      i = V("ijk,k->ij", o, a);
+      break;
+    case 4:
+      i = V("ijkl,l->ijk", o, a);
+      break;
+    case 5:
+      i = V("ijklm,m->ijkl", o, a);
+      break;
+    case 6:
+      i = V("ijklmn,n->ijklm", o, a);
+      break;
+    default:
+      throw new Error("Not a valid tensor rank.");
+  }
+  return i = W(i, -1), D(i, n);
+}
+const Vn = /* @__PURE__ */ f({ rgbToGrayscale_: Kn });
+function jn(e, r, s = 0, t = 0.5) {
+  const n = c(e, "image", "rotateWithOffset", "float32");
+  p(n.rank === 4, () => `Error in rotateWithOffset: image must be rank 4,but got rank ${n.rank}.`);
+  const o = { image: n }, a = { radians: r, fillValue: s, center: t };
+  return d.runKernel(Ys, o, a);
+}
+const Pn = /* @__PURE__ */ f({ rotateWithOffset_: jn });
+function K(e, r, s, t, n, o) {
+  t == null && (t = 0.5), n == null && (n = Number.NEGATIVE_INFINITY), o == null && (o = 0);
+  const a = e.shape[0];
+  return s = Math.min(s, a), p(0 <= t && t <= 1, () => `iouThreshold must be in [0, 1], but was '${t}'`), p(e.rank === 2, () => `boxes must be a 2D tensor, but was of rank '${e.rank}'`), p(e.shape[1] === 4, () => `boxes must have 4 columns, but 2nd dimension was ${e.shape[1]}`), p(r.rank === 1, () => "scores must be a 1D tensor"), p(r.shape[0] === a, () => `scores has incompatible shape with boxes. Expected ${a}, but was ${r.shape[0]}`), p(0 <= o && o <= 1, () => `softNmsSigma must be in [0, 1], but was '${o}'`), { maxOutputSize: s, iouThreshold: t, scoreThreshold: n, softNmsSigma: o };
+}
+function Yn(e, r, s, t = 0.5, n = Number.NEGATIVE_INFINITY) {
+  const o = c(e, "boxes", "nonMaxSuppression", "float32"), a = c(r, "scores", "nonMaxSuppression", "float32"), i = K(o, a, s, t, n);
+  s = i.maxOutputSize, t = i.iouThreshold, n = i.scoreThreshold;
+  const u = { maxOutputSize: s, iouThreshold: t, scoreThreshold: n };
+  return d.runKernel(Fs, { boxes: o, scores: a }, u);
+}
+const Fn = /* @__PURE__ */ f({ nonMaxSuppression_: Yn });
+async function Un(e, r, s, t = 0.5, n = Number.NEGATIVE_INFINITY) {
+  const o = c(e, "boxes", "nonMaxSuppressionAsync"), a = c(r, "scores", "nonMaxSuppressionAsync"), i = K(o, a, s, t, n);
+  s = i.maxOutputSize, t = i.iouThreshold, n = i.scoreThreshold;
+  const u = await Promise.all([o.data(), a.data()]), l = u[0], m = u[1], { selectedIndices: h } = sn(l, m, s, t, n);
+  return o !== e && o.dispose(), a !== r && a.dispose(), q(h, "int32");
+}
+const Zn = Un;
+function Hn(e, r, s, t = 0.5, n = Number.NEGATIVE_INFINITY, o = 0) {
+  const a = c(e, "boxes", "nonMaxSuppression"), i = c(r, "scores", "nonMaxSuppression"), u = K(a, i, s, t, n, o);
+  s = u.maxOutputSize, t = u.iouThreshold, n = u.scoreThreshold, o = u.softNmsSigma;
+  const l = { boxes: a, scores: i }, m = { maxOutputSize: s, iouThreshold: t, scoreThreshold: n, softNmsSigma: o }, h = d.runKernel(Us, l, m);
+  return { selectedIndices: h[0], selectedScores: h[1] };
+}
+const Jn = /* @__PURE__ */ f({ nonMaxSuppressionWithScore_: Hn });
+async function Xn(e, r, s, t = 0.5, n = Number.NEGATIVE_INFINITY, o = 0) {
+  const a = c(e, "boxes", "nonMaxSuppressionAsync"), i = c(r, "scores", "nonMaxSuppressionAsync"), u = K(a, i, s, t, n, o);
+  s = u.maxOutputSize, t = u.iouThreshold, n = u.scoreThreshold, o = u.softNmsSigma;
+  const l = await Promise.all([a.data(), i.data()]), m = l[0], h = l[1], { selectedIndices: _, selectedScores: $ } = nn(m, h, s, t, n, o);
+  return a !== e && a.dispose(), i !== r && i.dispose(), {
+    selectedIndices: q(_, "int32"),
+    selectedScores: q($)
+  };
+}
+const Qn = Xn;
+function se(e, r, s, t = 0.5, n = Number.NEGATIVE_INFINITY, o = !1) {
+  const a = c(e, "boxes", "nonMaxSuppression"), i = c(r, "scores", "nonMaxSuppression"), u = K(
+    a,
+    i,
+    s,
+    t,
+    n,
+    null
+    /* softNmsSigma */
+  ), l = u.maxOutputSize, m = u.iouThreshold, h = u.scoreThreshold, _ = { boxes: a, scores: i }, $ = {
+    maxOutputSize: l,
+    iouThreshold: m,
+    scoreThreshold: h,
+    padToMaxOutputSize: o
+  }, k = d.runKernel(Zs, _, $);
+  return { selectedIndices: k[0], validOutputs: k[1] };
+}
+const ne = /* @__PURE__ */ f({ nonMaxSuppressionPadded_: se });
+async function ee(e, r, s, t = 0.5, n = Number.NEGATIVE_INFINITY, o = !1) {
+  const a = c(e, "boxes", "nonMaxSuppressionAsync"), i = c(r, "scores", "nonMaxSuppressionAsync"), u = K(
+    a,
+    i,
+    s,
+    t,
+    n,
+    null
+    /* softNmsSigma */
+  ), l = u.maxOutputSize, m = u.iouThreshold, h = u.scoreThreshold, [_, $] = await Promise.all([a.data(), i.data()]), { selectedIndices: k, validOutputs: w } = en(_, $, l, m, h, o);
+  return a !== e && a.dispose(), i !== r && i.dispose(), {
+    selectedIndices: q(k, "int32"),
+    validOutputs: y(w, "int32")
+  };
+}
+const te = ee;
+function re(e, r, s = !1, t = !1) {
+  const n = c(e, "images", "resizeBilinear");
+  p(n.rank === 3 || n.rank === 4, () => `Error in resizeBilinear: x must be rank 3 or 4, but got rank ${n.rank}.`), p(r.length === 2, () => `Error in resizeBilinear: new shape must 2D, but got shape ${r}.`), p(t === !1 || s === !1, () => "Error in resizeBilinear: If halfPixelCenters is true, alignCorners must be false.");
+  let o = n, a = !1;
+  n.rank === 3 && (a = !0, o = I(n, [1, n.shape[0], n.shape[1], n.shape[2]]));
+  const i = { images: o }, u = { alignCorners: s, halfPixelCenters: t, size: r }, l = d.runKernel(Hs, i, u);
+  return a ? I(l, [l.shape[1], l.shape[2], l.shape[3]]) : l;
+}
+const oe = /* @__PURE__ */ f({ resizeBilinear_: re });
+function ae(e, r, s = !1, t = !1) {
+  const n = c(e, "images", "resizeNearestNeighbor");
+  p(n.rank === 3 || n.rank === 4, () => `Error in resizeNearestNeighbor: x must be rank 3 or 4, but got rank ${n.rank}.`), p(r.length === 2, () => `Error in resizeNearestNeighbor: new shape must 2D, but got shape ${r}.`), p(n.dtype === "float32" || n.dtype === "int32", () => "`images` must have `int32` or `float32` as dtype"), p(t === !1 || s === !1, () => "Error in resizeNearestNeighbor: If halfPixelCenters is true, alignCorners must be false.");
+  let o = n, a = !1;
+  n.rank === 3 && (a = !0, o = I(n, [1, n.shape[0], n.shape[1], n.shape[2]]));
+  const i = { images: o }, u = { alignCorners: s, halfPixelCenters: t, size: r }, l = d.runKernel(Js, i, u);
+  return a ? I(l, [l.shape[1], l.shape[2], l.shape[3]]) : l;
+}
+const ie = /* @__PURE__ */ f({ resizeNearestNeighbor_: ae });
+function ce(e, r = "binary", s = !1, t = 0.5) {
+  const n = c(e, "image", "threshold"), o = 0.2989, a = 0.587, i = 0.114, u = n.shape[0] * n.shape[1];
+  let l = b(q([t]), 255), m, h, _, $;
+  if (p(n.rank === 3, () => `Error in threshold: image must be rank 3,but got rank ${n.rank}.`), p(n.shape[2] === 3 || n.shape[2] === 1, () => `Error in threshold: image color channel must be equal to 3 or 1but got ${n.shape[2]}.`), p(n.dtype === "int32" || n.dtype === "float32", () => `Error in dtype: image dtype must be int32 or float32,but got dtype ${n.dtype}.`), p(r === "otsu" || r === "binary", () => `Method must be binary or otsu, but was ${r}`), n.shape[2] === 3) {
+    [m, h, _] = ds(n, [1, 1, 1], -1);
+    const T = b(m, o), x = b(h, a), R = b(_, i);
+    $ = O(O(T, x), R);
+  } else
+    $ = e;
+  if (r === "otsu") {
+    const T = un(D(Bn($), "int32"), tn([]), 256);
+    l = le(T, u);
+  }
+  const k = s ? ys($, l) : as($, l);
+  return D(b(k, 255), "int32");
+}
+function le(e, r) {
+  let s = q([-1]), t = q([0]), n = q([0]), o, a, i, u, l, m;
+  for (let h = 0; h < e.size - 1; h++) {
+    o = M(e, 0, h + 1), a = M(e, h + 1), l = S(E(o), r), m = S(E(a), r);
+    const _ = E(b(o, Z(0, o.size)));
+    i = S(_, E(o));
+    const $ = Ss(a.shape, o.size), k = O(Z(0, a.size), $), w = b(a, k);
+    u = S(E(w), E(a));
+    const T = g(i, u), x = g(i, u), R = b(l, m);
+    n = b(b(R, T), x);
+    const P = as(n, t);
+    t = C(P, n, t), s = C(P, q([h]), s);
+  }
+  return s;
+}
+const ue = /* @__PURE__ */ f({ threshold_: ce });
+function pe(e, r, s = "nearest", t = "constant", n = 0, o) {
+  const a = c(e, "image", "transform", "float32"), i = c(r, "transforms", "transform", "float32");
+  p(a.rank === 4, () => `Error in transform: image must be rank 4,but got rank ${a.rank}.`), p(i.rank === 2 && (i.shape[0] === a.shape[0] || i.shape[0] === 1) && i.shape[1] === 8, () => "Error in transform: Input transform should be batch x 8 or 1 x 8"), p(o == null || o.length === 2, () => `Error in transform: outputShape must be [height, width] or null, but got ${o}.`);
+  const u = { image: a, transforms: i }, l = { interpolation: s, fillMode: t, fillValue: n, outputShape: o };
+  return d.runKernel(Xs, u, l);
+}
+const fe = /* @__PURE__ */ f({ transform_: pe });
+function me(e, r, s) {
+  const t = c(e, "a", "bandPart");
+  p(t.rank >= 2, () => `bandPart(): Rank must be at least 2, got ${t.rank}.`);
+  const n = t.shape, [o, a] = t.shape.slice(-2);
+  let i, u;
+  typeof r == "number" ? (p(r % 1 === 0, () => `bandPart(): numLower must be an integer, got ${r}.`), p(r <= o, () => `bandPart(): numLower (${r}) must not be greater than the number of rows (${o}).`), i = c(r < 0 ? o : r, "numLower", "bandPart")) : (p(r.dtype === "int32", () => "bandPart(): numLower's dtype must be an int32."), i = C(ms(r, 0), o, os(r, o))), typeof s == "number" ? (p(s % 1 === 0, () => `bandPart(): numUpper must be an integer, got ${s}.`), p(s <= a, () => `bandPart(): numUpper (${s}) must not be greater than the number of columns (${a}).`), u = c(s < 0 ? a : s, "numUpper", "bandPart")) : (p(s.dtype === "int32", () => "bandPart(): numUpper's dtype must be an int32."), u = C(ms(s, 0), a, os(s, a)));
+  const l = I(Z(0, o, 1, "int32"), [-1, 1]), m = Z(0, a, 1, "int32"), h = g(l, m), _ = Sn(ys(h, i), En(h, j(u))), $ = rn([o, a], t.dtype);
+  return I(H(ks(I(t, [-1, o, a])).map((k) => C(_, k, $))), n);
+}
+const he = /* @__PURE__ */ f({ bandPart_: me });
+function be(e) {
+  let r;
+  if (Array.isArray(e)) {
+    r = !1, p(e != null && e.length > 0, () => "Gram-Schmidt process: input must not be null, undefined, or empty");
+    const n = e[0].shape[0];
+    for (let o = 1; o < e.length; ++o)
+      p(e[o].shape[0] === n, () => `Gram-Schmidt: Non-unique lengths found in the input vectors: (${e[o].shape[0]} vs. ${n})`);
+  } else
+    r = !0, e = ds(e, e.shape[0], 0).map((n) => an(n, [0]));
+  p(e.length <= e[0].shape[0], () => `Gram-Schmidt: Number of vectors (${e.length}) exceeds number of dimensions (${e[0].shape[0]}).`);
+  const s = [], t = e;
+  for (let n = 0; n < e.length; ++n)
+    s.push(d.tidy(() => {
+      let o = t[n];
+      if (n > 0)
+        for (let a = 0; a < n; ++a) {
+          const i = b(E(b(s[a], o)), s[a]);
+          o = g(o, i);
+        }
+      return S(o, _s(o, "euclidean"));
+    }));
+  return r ? H(s, 0) : s;
+}
+const de = /* @__PURE__ */ f({ gramSchmidt_: be });
+function ge(e, r = !1) {
+  if (p(e.rank >= 2, () => `qr() requires input tensor to have a rank >= 2, but got rank ${e.rank}`), e.rank === 2)
+    return hs(e, r);
+  {
+    const s = e.shape.slice(0, e.shape.length - 2).reduce((u, l) => u * l), t = ks(I(e, [
+      s,
+      e.shape[e.shape.length - 2],
+      e.shape[e.shape.length - 1]
+    ]), 0), n = [], o = [];
+    t.forEach((u) => {
+      const [l, m] = hs(u, r);
+      n.push(l), o.push(m);
+    });
+    const a = I(H(n, 0), e.shape), i = I(H(o, 0), e.shape);
+    return [a, i];
+  }
+}
+function hs(e, r = !1) {
+  return d.tidy(() => {
+    p(e.shape.length === 2, () => `qr2d() requires a 2D Tensor, but got a ${e.shape.length}D Tensor.`);
+    const s = e.shape[0], t = e.shape[1];
+    let n = dn(s), o = Q(e);
+    const a = ts([[1]], [1, 1]);
+    let i = Q(a);
+    const u = s >= t ? t : s;
+    for (let l = 0; l < u; ++l) {
+      const m = o, h = i, _ = n;
+      [i, o, n] = d.tidy(() => {
+        const $ = M(o, [l, l], [s - l, 1]), k = _s($), w = M(o, [l, l], [1, 1]), T = C(as(w, 0), ts([[-1]]), ts([[1]])), x = g(w, b(T, k)), R = S($, x);
+        R.shape[0] === 1 ? i = Q(a) : i = es([
+          a,
+          M(R, [1, 0], [R.shape[0] - 1, R.shape[1]])
+        ], 0);
+        const P = j(S(G(T, x), k)), Y = M(o, [l, 0], [s - l, t]), J = b(P, i), is = us(i);
+        if (l === 0)
+          o = g(Y, G(J, G(is, Y)));
+        else {
+          const X = g(Y, G(J, G(is, Y)));
+          o = es([M(o, [0, 0], [l, t]), X], 0);
+        }
+        const cs = us(J), F = M(n, [0, l], [s, n.shape[1] - l]);
+        if (l === 0)
+          n = g(F, G(G(F, i), cs));
+        else {
+          const X = g(F, G(G(F, i), cs));
+          n = es([M(n, [0, 0], [s, l]), X], 1);
+        }
+        return [i, o, n];
+      }), Ts([m, h, _]);
+    }
+    return !r && s > t && (n = M(n, [0, 0], [s, t]), o = M(o, [0, 0], [t, t])), [n, o];
+  });
+}
+const $e = /* @__PURE__ */ f({ qr_: ge });
+var N;
+(function(e) {
+  e[e.NONE = 0] = "NONE", e[e.MEAN = 1] = "MEAN", e[e.SUM = 2] = "SUM", e[e.SUM_BY_NONZERO_WEIGHTS = 3] = "SUM_BY_NONZERO_WEIGHTS";
+})(N || (N = {}));
+function Ee(e, r, s = N.SUM_BY_NONZERO_WEIGHTS) {
+  const t = c(e, "losses", "computeWeightedLoss");
+  let n = null;
+  r != null && (n = c(r, "weights", "computeWeightedLoss"));
+  const o = n == null ? t : b(t, n);
+  if (s === N.NONE)
+    return o;
+  if (s === N.SUM)
+    return E(o);
+  if (s === N.MEAN) {
+    if (n == null)
+      return Mn(o);
+    {
+      const a = t.size / n.size, i = S(E(o), E(n));
+      return a > 1 ? S(i, y(a)) : i;
+    }
+  }
+  if (s === N.SUM_BY_NONZERO_WEIGHTS) {
+    if (n == null)
+      return S(E(o), y(t.size));
+    {
+      const a = b(n, cn(t.shape)), i = D(E(qn(a, y(0))), "float32");
+      return S(E(o), i);
+    }
+  }
+  throw Error(`Unknown reduction: ${s}`);
+}
+const z = /* @__PURE__ */ f({ computeWeightedLoss_: Ee });
+function _e(e, r, s, t = N.SUM_BY_NONZERO_WEIGHTS) {
+  const n = c(e, "labels", "absoluteDifference"), o = c(r, "predictions", "absoluteDifference");
+  let a = null;
+  s != null && (a = c(s, "weights", "absoluteDifference")), L(n.shape, o.shape, "Error in absoluteDifference: ");
+  const i = A(g(n, o));
+  return z(i, a, t);
+}
+const ye = /* @__PURE__ */ f({ absoluteDifference_: _e });
+function ke(e, r, s, t, n = N.SUM_BY_NONZERO_WEIGHTS) {
+  const o = c(e, "labels", "cosineDistance"), a = c(r, "predictions", "cosineDistance");
+  let i = null;
+  t != null && (i = c(t, "weights", "cosineDistance")), L(o.shape, a.shape, "Error in cosineDistance: ");
+  const u = y(1), l = g(u, E(b(o, a), s, !0));
+  return z(l, i, n);
+}
+const Ne = /* @__PURE__ */ f({ cosineDistance_: ke });
+function Ie(e, r, s, t = N.SUM_BY_NONZERO_WEIGHTS) {
+  let n = c(e, "labels", "hingeLoss");
+  const o = c(r, "predictions", "hingeLoss");
+  let a = null;
+  s != null && (a = c(s, "weights", "hingeLoss")), L(n.shape, o.shape, "Error in hingeLoss: ");
+  const i = y(1);
+  n = g(b(y(2), n), i);
+  const u = $s(g(i, b(n, o)));
+  return z(u, a, t);
+}
+const Se = /* @__PURE__ */ f({ hingeLoss_: Ie });
+function Te(e, r, s, t = 1, n = N.SUM_BY_NONZERO_WEIGHTS) {
+  const o = c(e, "labels", "huberLoss"), a = c(r, "predictions", "huberLoss");
+  let i = null;
+  s != null && (i = c(s, "weights", "huberLoss")), L(o.shape, a.shape, "Error in huberLoss: ");
+  const u = y(t), l = A(g(a, o)), m = os(l, u), h = g(l, m), _ = O(b(y(0.5), bs(m)), b(u, h));
+  return z(_, i, n);
+}
+const Me = /* @__PURE__ */ f({ huberLoss_: Te });
+function Ae(e, r, s, t = 1e-7, n = N.SUM_BY_NONZERO_WEIGHTS) {
+  const o = c(e, "labels", "logLoss"), a = c(r, "predictions", "logLoss");
+  let i = null;
+  s != null && (i = c(s, "weights", "logLoss")), L(o.shape, a.shape, "Error in logLoss: ");
+  const u = y(1), l = y(t), m = j(b(o, ps(O(a, l)))), h = b(g(u, o), ps(O(g(u, a), l))), _ = g(m, h);
+  return z(_, i, n);
+}
+const we = /* @__PURE__ */ f({ logLoss_: Ae });
+function qe(e, r, s, t = N.SUM_BY_NONZERO_WEIGHTS) {
+  const n = c(e, "labels", "meanSquaredError"), o = c(r, "predictions", "meanSquaredError");
+  let a = null;
+  s != null && (a = c(s, "weights", "meanSquaredError")), L(n.shape, o.shape, "Error in meanSquaredError: ");
+  const i = Gn(n, o);
+  return z(i, a, t);
+}
+const De = /* @__PURE__ */ f({ meanSquaredError_: qe });
+function Be(e, r) {
+  const s = c(e, "labels", "sigmoidCrossEntropyWithLogits"), t = c(r, "logits", "sigmoidCrossEntropyWithLogits");
+  L(s.shape, t.shape, "Error in sigmoidCrossEntropyWithLogits: ");
+  const n = $s(t), o = b(t, s), a = Nn(rs(j(A(t))));
+  return O(g(n, o), a);
+}
+function xe(e, r, s, t = 0, n = N.SUM_BY_NONZERO_WEIGHTS) {
+  let o = c(e, "multiClassLabels", "sigmoidCrossEntropy");
+  const a = c(r, "logits", "sigmoidCrossEntropy");
+  let i = null;
+  if (s != null && (i = c(s, "weights", "sigmoidCrossEntropy")), L(o.shape, a.shape, "Error in sigmoidCrossEntropy: "), t > 0) {
+    const l = y(t), m = y(1), h = y(0.5);
+    o = O(b(o, g(m, l)), b(h, l));
+  }
+  const u = Be(o, a);
+  return z(u, i, n);
+}
+const Ge = /* @__PURE__ */ f({ sigmoidCrossEntropy_: xe });
+function Oe(e, r, s = -1) {
+  if (s === -1 && (s = r.rank - 1), s !== r.rank - 1)
+    throw Error(`Softmax cross entropy along a non-last dimension is not yet supported. Labels / logits was rank ${r.rank} and dim was ${s}`);
+  return Ms((n, o, a) => {
+    const u = on(o, [s], !0), l = g(D(o, "float32"), u);
+    a([n, l]);
+    const m = j(b(l, n));
+    return { value: E(m, [s]), gradFunc: ($, k) => {
+      const [w, T] = k, x = gs($.shape, [s]);
+      return [
+        b(I($, x), g(D(w, "float32"), rs(T))),
+        b(I($, x), g(rs(T), D(w, "float32")))
+      ];
+    } };
+  })(e, r);
+}
+function Le(e, r, s, t = 0, n = N.SUM_BY_NONZERO_WEIGHTS) {
+  let o = c(e, "onehotLabels", "softmaxCrossEntropy");
+  const a = c(r, "logits", "softmaxCrossEntropy");
+  let i = null;
+  if (s != null && (i = c(s, "weights", "softmaxCrossEntropy")), L(o.shape, a.shape, "Error in softmaxCrossEntropy: "), t > 0) {
+    const l = y(t), m = y(1), h = y(o.shape[1]);
+    o = O(b(o, g(m, l)), S(l, h));
+  }
+  const u = Oe(o, a);
+  return z(u, i, n);
+}
+const ze = /* @__PURE__ */ f({ softmaxCrossEntropy_: Le });
+const lt = {
+  flipLeftRight: Wn,
+  grayscaleToRGB: Cn,
+  resizeNearestNeighbor: ie,
+  resizeBilinear: oe,
+  rgbToGrayscale: Vn,
+  rotateWithOffset: Pn,
+  cropAndResize: zn,
+  nonMaxSuppression: Fn,
+  nonMaxSuppressionAsync: Zn,
+  nonMaxSuppressionWithScore: Jn,
+  nonMaxSuppressionWithScoreAsync: Qn,
+  nonMaxSuppressionPadded: ne,
+  nonMaxSuppressionPaddedAsync: te,
+  threshold: ue,
+  transform: fe
+}, ut = {
+  bandPart: he,
+  gramSchmidt: de,
+  qr: $e
+}, pt = {
+  absoluteDifference: ye,
+  computeWeightedLoss: z,
+  cosineDistance: Ne,
+  hingeLoss: Se,
+  huberLoss: Me,
+  logLoss: we,
+  meanSquaredError: De,
+  sigmoidCrossEntropy: Ge,
+  softmaxCrossEntropy: ze
+};
+export {
+  pt as a,
+  Sn as b,
+  ys as c,
+  as as d,
+  ms as e,
+  dn as f,
+  En as g,
+  Nn as h,
+  os as i,
+  lt as j,
+  fs as k,
+  ut as l,
+  Mn as m,
+  qn as n,
+  _s as o,
+  ie as p,
+  Bn as q,
+  oe as r,
+  Gn as s,
+  ks as u,
+  C as w
+};

package/dist/pack16-CFUqumar.js

@@ -0,0 +1,41 @@
+import { isPackedTensor as t, packTensor as u } from "./utilities/packed.js";
+import { e as o } from "./index-ZyQhjEPo.js";
+import { a as i } from "./tensor_util-DV-FP5Q3.js";
+import { s as p } from "./slice-D_gkkqZK.js";
+const s = {
+  kernelName: "Unpack16",
+  inputsToSave: [],
+  outputsToSave: [],
+  gradFunc: (n) => ({
+    x: () => k(n)
+  })
+};
+i(s);
+function c(n, a = 1, e = !1) {
+  if (!t(n))
+    return n;
+  const r = o().runKernel("Unpack16", { x: n }, { scaling: a });
+  return e && n.dispose(), r;
+}
+const f = {
+  kernelName: "Pack16",
+  inputsToSave: [],
+  outputsToSave: [],
+  gradFunc: (n, a, e) => ({
+    x: () => {
+      const r = c(n);
+      return e.originalShape && e.padding && e.padding > 0 ? p(r, new Array(r.shape.length).fill(0), e.originalShape) : r;
+    }
+  })
+};
+i(f);
+function k(n, a = 1, e = 0) {
+  const r = o().runKernel("Pack16", { x: n }, { scaling: a, padding: e });
+  return u(r), r;
+}
+export {
+  s as a,
+  f as b,
+  k as p,
+  c as u
+};