@genai-fi/nanogpt 0.10.1 → 0.10.3

package/dist/ops-B5yanEdW.js

@@ -0,0 +1,476 @@
+import { A as b, B as u, l as p, E as k, bf as hs, bg as bs, at as ds, bh as gs, bi as Es, X as W, bj as $s, bk as ys, bl as _s, bm as Ns, b as $, m as h, x as G, w as S, q as Ss, c as d, bn as ks, D as K, d as Is, ab as B, aZ as ns, b0 as Ts, a6 as Ms } from "./index-DOvlwCh-.js";
+import { t as j } from "./tile-mbfagpsB.js";
+import { e as R } from "./expand_dims-DT4tEPwA.js";
+import { t as x } from "./tensor1d-D11P_7Dp.js";
+import { n as xs, a as As, b as ws } from "./non_max_suppression_impl-B2W7YjZB.js";
+import { r as Os, l as ls, g as ts, w as q, a as rs, m as Q, b as Gs, c as Bs, u as us, n as ps, d as Ds, e as Ls, s as Ws, f as Rs, h as qs, i as zs } from "./resize_nearest_neighbor-B19mCEg2.js";
+import { s as ms } from "./split-CVLc0w--.js";
+import { s as _ } from "./sum-DWAtNGez.js";
+import { s as T } from "./slice-BfEGSH82.js";
+import { r as F } from "./range-BklejeeW.js";
+import { t as Vs } from "./tensor-DJoc7gJU.js";
+import { n as C, t as as } from "./transpose-ClWiBS_b.js";
+import { r as O } from "./reshape-ByE68wS9.js";
+import { s as Z } from "./stack-Cf4n9h0N.js";
+import { z as Cs } from "./zeros-KnWaWf-X.js";
+import { s as Ps } from "./squeeze-C7Z2srUo.js";
+import { c as X } from "./concat-BV8bt5H-.js";
+import { m as w } from "./mat_mul-SjpJRLyL.js";
+import { t as J } from "./tensor2d-Bs9wZRc7.js";
+import { o as Ys } from "./ones-D2rT0xk2.js";
+import { r as fs } from "./relu-CP0ZcxWO.js";
+import { a as is, e as ss, l as vs } from "./log_sum_exp-ngO0-4pK.js";
+import { e as js } from "./axis_util-BaG7mf5A.js";
+function Fs(e, a, n) {
+  const r = u(e, "x", "bincount"), t = u(a, "weights", "bincount");
+  p(r.dtype === "int32", () => `Error in bincount: input dtype must be int32, but got ${r.dtype}`), p(n >= 0, () => `size must be non-negative, but got ${n}.`), p(t.size === r.size || t.size === 0, () => `Error in bincount: weights must have the same size as input or0-length, but got input shape: ${r.shape}, weights shape: ${t.shape}.`);
+  const s = { x: r, weights: t }, o = { size: n };
+  return k.runKernel(hs, s, o);
+}
+const Zs = /* @__PURE__ */ b({ bincount_: Fs });
+function Us(e, ...a) {
+  const n = a.map((t, s) => u(t, `tensors${s}`, "einsum")), r = { equation: e };
+  return k.runKernel(bs, n, r);
+}
+const V = /* @__PURE__ */ b({ einsum_: Us });
+function Hs(e, a, n, r = "float32") {
+  a == null && (a = e);
+  const t = ds([e, a], r), s = e <= a ? e : a;
+  for (let i = 0; i < s; ++i)
+    t.set(1, i, i);
+  const o = O(t.toTensor(), [e, a]);
+  if (n == null)
+    return o;
+  if (n.length === 1)
+    return j(R(o, 0), [n[0], 1, 1]);
+  if (n.length === 2)
+    return j(R(R(o, 0), 0), [n[0], n[1], 1, 1]);
+  if (n.length === 3)
+    return j(R(R(R(o, 0), 0), 0), [
+      n[0],
+      n[1],
+      n[2],
+      1,
+      1
+    ]);
+  throw new Error(`eye() currently supports only 1D and 2D batchShapes, but received ${n.length}D.`);
+}
+const Ks = /* @__PURE__ */ b({ eye_: Hs });
+function Xs(e, a, n, r, t = "bilinear", s = 0) {
+  const o = u(e, "image", "cropAndResize"), i = u(a, "boxes", "cropAndResize", "float32"), l = u(n, "boxInd", "cropAndResize", "int32"), c = i.shape[0];
+  p(o.rank === 4, () => `Error in cropAndResize: image must be rank 4,but got rank ${o.rank}.`), p(i.rank === 2 && i.shape[1] === 4, () => `Error in cropAndResize: boxes must be have size [${c},4] but had shape ${i.shape}.`), p(l.rank === 1 && l.shape[0] === c, () => `Error in cropAndResize: boxInd must be have size [${c}] but had shape ${i.shape}.`), p(r.length === 2, () => `Error in cropAndResize: cropSize must be of length 2, but got length ${r.length}.`), p(r[0] >= 1 && r[1] >= 1, () => `cropSize must be atleast [1,1], but was ${r}`), p(t === "bilinear" || t === "nearest", () => `method must be bilinear or nearest, but was ${t}`);
+  const f = { image: o, boxes: i, boxInd: l }, m = { method: t, extrapolationValue: s, cropSize: r };
+  return k.runKernel(gs, f, m);
+}
+const Js = /* @__PURE__ */ b({ cropAndResize_: Xs });
+function Qs(e) {
+  const a = u(e, "image", "flipLeftRight", "float32");
+  p(a.rank === 4, () => `Error in flipLeftRight: image must be rank 4,but got rank ${a.rank}.`);
+  const n = { image: a };
+  return k.runKernel(Es, n, {});
+}
+const sn = /* @__PURE__ */ b({ flipLeftRight_: Qs });
+function nn(e) {
+  const a = u(e, "image", "grayscaleToRGB"), n = a.rank - 1, r = a.shape[n];
+  p(a.rank >= 2, () => `Error in grayscaleToRGB: images must be at least rank 2, but got rank ${a.rank}.`), p(r === 1, () => `Error in grayscaleToRGB: last dimension of a grayscale image should be size 1, but got size ${r}.`);
+  const t = new Array(a.rank);
+  return t.fill(1, 0, n), t[n] = 3, j(a, t);
+}
+const tn = /* @__PURE__ */ b({ grayscaleToRGB_: nn });
+function en(e) {
+  const a = u(e, "image", "RGBToGrayscale"), n = a.rank - 1, r = a.shape[n];
+  p(a.rank >= 2, () => `Error in RGBToGrayscale: images must be at least rank 2, but got rank ${a.rank}.`), p(r === 3, () => `Error in RGBToGrayscale: last dimension of an RGB image should be size 3, but got size ${r}.`);
+  const t = a.dtype, s = W(a, "float32"), o = x([0.2989, 0.587, 0.114]);
+  let i;
+  switch (a.rank) {
+    case 2:
+      i = V("ij,j->i", s, o);
+      break;
+    case 3:
+      i = V("ijk,k->ij", s, o);
+      break;
+    case 4:
+      i = V("ijkl,l->ijk", s, o);
+      break;
+    case 5:
+      i = V("ijklm,m->ijkl", s, o);
+      break;
+    case 6:
+      i = V("ijklmn,n->ijklm", s, o);
+      break;
+    default:
+      throw new Error("Not a valid tensor rank.");
+  }
+  return i = R(i, -1), W(i, t);
+}
+const on = /* @__PURE__ */ b({ rgbToGrayscale_: en });
+function rn(e, a, n = 0, r = 0.5) {
+  const t = u(e, "image", "rotateWithOffset", "float32");
+  p(t.rank === 4, () => `Error in rotateWithOffset: image must be rank 4,but got rank ${t.rank}.`);
+  const s = { image: t }, o = { radians: a, fillValue: n, center: r };
+  return k.runKernel($s, s, o);
+}
+const an = /* @__PURE__ */ b({ rotateWithOffset_: rn });
+function z(e, a, n, r, t, s) {
+  r == null && (r = 0.5), t == null && (t = Number.NEGATIVE_INFINITY), s == null && (s = 0);
+  const o = e.shape[0];
+  return n = Math.min(n, o), p(0 <= r && r <= 1, () => `iouThreshold must be in [0, 1], but was '${r}'`), 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(a.rank === 1, () => "scores must be a 1D tensor"), p(a.shape[0] === o, () => `scores has incompatible shape with boxes. Expected ${o}, but was ${a.shape[0]}`), p(0 <= s && s <= 1, () => `softNmsSigma must be in [0, 1], but was '${s}'`), { maxOutputSize: n, iouThreshold: r, scoreThreshold: t, softNmsSigma: s };
+}
+function cn(e, a, n, r = 0.5, t = Number.NEGATIVE_INFINITY) {
+  const s = u(e, "boxes", "nonMaxSuppression", "float32"), o = u(a, "scores", "nonMaxSuppression", "float32"), i = z(s, o, n, r, t);
+  n = i.maxOutputSize, r = i.iouThreshold, t = i.scoreThreshold;
+  const l = { maxOutputSize: n, iouThreshold: r, scoreThreshold: t };
+  return k.runKernel(ys, { boxes: s, scores: o }, l);
+}
+const ln = /* @__PURE__ */ b({ nonMaxSuppression_: cn });
+async function un(e, a, n, r = 0.5, t = Number.NEGATIVE_INFINITY) {
+  const s = u(e, "boxes", "nonMaxSuppressionAsync"), o = u(a, "scores", "nonMaxSuppressionAsync"), i = z(s, o, n, r, t);
+  n = i.maxOutputSize, r = i.iouThreshold, t = i.scoreThreshold;
+  const l = await Promise.all([s.data(), o.data()]), c = l[0], f = l[1], { selectedIndices: m } = xs(c, f, n, r, t);
+  return s !== e && s.dispose(), o !== a && o.dispose(), x(m, "int32");
+}
+const pn = un;
+function mn(e, a, n, r = 0.5, t = Number.NEGATIVE_INFINITY, s = 0) {
+  const o = u(e, "boxes", "nonMaxSuppression"), i = u(a, "scores", "nonMaxSuppression"), l = z(o, i, n, r, t, s);
+  n = l.maxOutputSize, r = l.iouThreshold, t = l.scoreThreshold, s = l.softNmsSigma;
+  const c = { boxes: o, scores: i }, f = { maxOutputSize: n, iouThreshold: r, scoreThreshold: t, softNmsSigma: s }, m = k.runKernel(_s, c, f);
+  return { selectedIndices: m[0], selectedScores: m[1] };
+}
+const fn = /* @__PURE__ */ b({ nonMaxSuppressionWithScore_: mn });
+async function hn(e, a, n, r = 0.5, t = Number.NEGATIVE_INFINITY, s = 0) {
+  const o = u(e, "boxes", "nonMaxSuppressionAsync"), i = u(a, "scores", "nonMaxSuppressionAsync"), l = z(o, i, n, r, t, s);
+  n = l.maxOutputSize, r = l.iouThreshold, t = l.scoreThreshold, s = l.softNmsSigma;
+  const c = await Promise.all([o.data(), i.data()]), f = c[0], m = c[1], { selectedIndices: E, selectedScores: g } = As(f, m, n, r, t, s);
+  return o !== e && o.dispose(), i !== a && i.dispose(), {
+    selectedIndices: x(E, "int32"),
+    selectedScores: x(g)
+  };
+}
+const bn = hn;
+function dn(e, a, n, r = 0.5, t = Number.NEGATIVE_INFINITY, s = !1) {
+  const o = u(e, "boxes", "nonMaxSuppression"), i = u(a, "scores", "nonMaxSuppression"), l = z(
+    o,
+    i,
+    n,
+    r,
+    t,
+    null
+    /* softNmsSigma */
+  ), c = l.maxOutputSize, f = l.iouThreshold, m = l.scoreThreshold, E = { boxes: o, scores: i }, g = {
+    maxOutputSize: c,
+    iouThreshold: f,
+    scoreThreshold: m,
+    padToMaxOutputSize: s
+  }, y = k.runKernel(Ns, E, g);
+  return { selectedIndices: y[0], validOutputs: y[1] };
+}
+const gn = /* @__PURE__ */ b({ nonMaxSuppressionPadded_: dn });
+async function En(e, a, n, r = 0.5, t = Number.NEGATIVE_INFINITY, s = !1) {
+  const o = u(e, "boxes", "nonMaxSuppressionAsync"), i = u(a, "scores", "nonMaxSuppressionAsync"), l = z(
+    o,
+    i,
+    n,
+    r,
+    t,
+    null
+    /* softNmsSigma */
+  ), c = l.maxOutputSize, f = l.iouThreshold, m = l.scoreThreshold, [E, g] = await Promise.all([o.data(), i.data()]), { selectedIndices: y, validOutputs: M } = ws(E, g, c, f, m, s);
+  return o !== e && o.dispose(), i !== a && i.dispose(), {
+    selectedIndices: x(y, "int32"),
+    validOutputs: $(M, "int32")
+  };
+}
+const $n = En;
+function yn(e, a = "binary", n = !1, r = 0.5) {
+  const t = u(e, "image", "threshold"), s = 0.2989, o = 0.587, i = 0.114, l = t.shape[0] * t.shape[1];
+  let c = h(x([r]), 255), f, m, E, g;
+  if (p(t.rank === 3, () => `Error in threshold: image must be rank 3,but got rank ${t.rank}.`), p(t.shape[2] === 3 || t.shape[2] === 1, () => `Error in threshold: image color channel must be equal to 3 or 1but got ${t.shape[2]}.`), p(t.dtype === "int32" || t.dtype === "float32", () => `Error in dtype: image dtype must be int32 or float32,but got dtype ${t.dtype}.`), p(a === "otsu" || a === "binary", () => `Method must be binary or otsu, but was ${a}`), t.shape[2] === 3) {
+    [f, m, E] = ms(t, [1, 1, 1], -1);
+    const I = h(f, s), A = h(m, o), L = h(E, i);
+    g = G(G(I, A), L);
+  } else
+    g = e;
+  if (a === "otsu") {
+    const I = Zs(W(Os(g), "int32"), Vs([]), 256);
+    c = _n(I, l);
+  }
+  const y = n ? ls(g, c) : ts(g, c);
+  return W(h(y, 255), "int32");
+}
+function _n(e, a) {
+  let n = x([-1]), r = x([0]), t = x([0]), s, o, i, l, c, f;
+  for (let m = 0; m < e.size - 1; m++) {
+    s = T(e, 0, m + 1), o = T(e, m + 1), c = S(_(s), a), f = S(_(o), a);
+    const E = _(h(s, F(0, s.size)));
+    i = S(E, _(s));
+    const g = Ss(o.shape, s.size), y = G(F(0, o.size), g), M = h(o, y);
+    l = S(_(M), _(o));
+    const I = d(i, l), A = d(i, l), L = h(c, f);
+    t = h(h(L, I), A);
+    const P = ts(t, r);
+    r = q(P, t, r), n = q(P, x([m]), n);
+  }
+  return n;
+}
+const Nn = /* @__PURE__ */ b({ threshold_: yn });
+function Sn(e, a, n = "nearest", r = "constant", t = 0, s) {
+  const o = u(e, "image", "transform", "float32"), i = u(a, "transforms", "transform", "float32");
+  p(o.rank === 4, () => `Error in transform: image must be rank 4,but got rank ${o.rank}.`), p(i.rank === 2 && (i.shape[0] === o.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(s == null || s.length === 2, () => `Error in transform: outputShape must be [height, width] or null, but got ${s}.`);
+  const l = { image: o, transforms: i }, c = { interpolation: n, fillMode: r, fillValue: t, outputShape: s };
+  return k.runKernel(ks, l, c);
+}
+const kn = /* @__PURE__ */ b({ transform_: Sn });
+function In(e, a, n) {
+  const r = u(e, "a", "bandPart");
+  p(r.rank >= 2, () => `bandPart(): Rank must be at least 2, got ${r.rank}.`);
+  const t = r.shape, [s, o] = r.shape.slice(-2);
+  let i, l;
+  typeof a == "number" ? (p(a % 1 === 0, () => `bandPart(): numLower must be an integer, got ${a}.`), p(a <= s, () => `bandPart(): numLower (${a}) must not be greater than the number of rows (${s}).`), i = u(a < 0 ? s : a, "numLower", "bandPart")) : (p(a.dtype === "int32", () => "bandPart(): numLower's dtype must be an int32."), i = q(rs(a, 0), s, Q(a, s))), typeof n == "number" ? (p(n % 1 === 0, () => `bandPart(): numUpper must be an integer, got ${n}.`), p(n <= o, () => `bandPart(): numUpper (${n}) must not be greater than the number of columns (${o}).`), l = u(n < 0 ? o : n, "numUpper", "bandPart")) : (p(n.dtype === "int32", () => "bandPart(): numUpper's dtype must be an int32."), l = q(rs(n, 0), o, Q(n, o)));
+  const c = O(F(0, s, 1, "int32"), [-1, 1]), f = F(0, o, 1, "int32"), m = d(c, f), E = Gs(ls(m, i), Bs(m, C(l))), g = Cs([s, o], r.dtype);
+  return O(Z(us(O(r, [-1, s, o])).map((y) => q(E, y, g))), t);
+}
+const Tn = /* @__PURE__ */ b({ bandPart_: In });
+function Mn(e) {
+  let a;
+  if (Array.isArray(e)) {
+    a = !1, p(e != null && e.length > 0, () => "Gram-Schmidt process: input must not be null, undefined, or empty");
+    const t = e[0].shape[0];
+    for (let s = 1; s < e.length; ++s)
+      p(e[s].shape[0] === t, () => `Gram-Schmidt: Non-unique lengths found in the input vectors: (${e[s].shape[0]} vs. ${t})`);
+  } else
+    a = !0, e = ms(e, e.shape[0], 0).map((t) => Ps(t, [0]));
+  p(e.length <= e[0].shape[0], () => `Gram-Schmidt: Number of vectors (${e.length}) exceeds number of dimensions (${e[0].shape[0]}).`);
+  const n = [], r = e;
+  for (let t = 0; t < e.length; ++t)
+    n.push(k.tidy(() => {
+      let s = r[t];
+      if (t > 0)
+        for (let o = 0; o < t; ++o) {
+          const i = h(_(h(n[o], s)), n[o]);
+          s = d(s, i);
+        }
+      return S(s, ps(s, "euclidean"));
+    }));
+  return a ? Z(n, 0) : n;
+}
+const xn = /* @__PURE__ */ b({ gramSchmidt_: Mn });
+function An(e, a = !1) {
+  if (p(e.rank >= 2, () => `qr() requires input tensor to have a rank >= 2, but got rank ${e.rank}`), e.rank === 2)
+    return cs(e, a);
+  {
+    const n = e.shape.slice(0, e.shape.length - 2).reduce((l, c) => l * c), r = us(O(e, [
+      n,
+      e.shape[e.shape.length - 2],
+      e.shape[e.shape.length - 1]
+    ]), 0), t = [], s = [];
+    r.forEach((l) => {
+      const [c, f] = cs(l, a);
+      t.push(c), s.push(f);
+    });
+    const o = O(Z(t, 0), e.shape), i = O(Z(s, 0), e.shape);
+    return [o, i];
+  }
+}
+function cs(e, a = !1) {
+  return k.tidy(() => {
+    p(e.shape.length === 2, () => `qr2d() requires a 2D Tensor, but got a ${e.shape.length}D Tensor.`);
+    const n = e.shape[0], r = e.shape[1];
+    let t = Ks(n), s = K(e);
+    const o = J([[1]], [1, 1]);
+    let i = K(o);
+    const l = n >= r ? r : n;
+    for (let c = 0; c < l; ++c) {
+      const f = s, m = i, E = t;
+      [i, s, t] = k.tidy(() => {
+        const g = T(s, [c, c], [n - c, 1]), y = ps(g), M = T(s, [c, c], [1, 1]), I = q(ts(M, 0), J([[-1]]), J([[1]])), A = d(M, h(I, y)), L = S(g, A);
+        L.shape[0] === 1 ? i = K(o) : i = X([
+          o,
+          T(L, [1, 0], [L.shape[0] - 1, L.shape[1]])
+        ], 0);
+        const P = C(S(w(I, A), y)), Y = T(s, [c, 0], [n - c, r]), U = h(P, i), es = as(i);
+        if (c === 0)
+          s = d(Y, w(U, w(es, Y)));
+        else {
+          const H = d(Y, w(U, w(es, Y)));
+          s = X([T(s, [0, 0], [c, r]), H], 0);
+        }
+        const os = as(U), v = T(t, [0, c], [n, t.shape[1] - c]);
+        if (c === 0)
+          t = d(v, w(w(v, i), os));
+        else {
+          const H = d(v, w(w(v, i), os));
+          t = X([T(t, [0, 0], [n, c]), H], 1);
+        }
+        return [i, s, t];
+      }), Is([f, m, E]);
+    }
+    return !a && n > r && (t = T(t, [0, 0], [n, r]), s = T(s, [0, 0], [r, r])), [t, s];
+  });
+}
+const wn = /* @__PURE__ */ b({ qr_: An });
+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 On(e, a, n = N.SUM_BY_NONZERO_WEIGHTS) {
+  const r = u(e, "losses", "computeWeightedLoss");
+  let t = null;
+  a != null && (t = u(a, "weights", "computeWeightedLoss"));
+  const s = t == null ? r : h(r, t);
+  if (n === N.NONE)
+    return s;
+  if (n === N.SUM)
+    return _(s);
+  if (n === N.MEAN) {
+    if (t == null)
+      return Ds(s);
+    {
+      const o = r.size / t.size, i = S(_(s), _(t));
+      return o > 1 ? S(i, $(o)) : i;
+    }
+  }
+  if (n === N.SUM_BY_NONZERO_WEIGHTS) {
+    if (t == null)
+      return S(_(s), $(r.size));
+    {
+      const o = h(t, Ys(r.shape)), i = W(_(Ls(o, $(0))), "float32");
+      return S(_(s), i);
+    }
+  }
+  throw Error(`Unknown reduction: ${n}`);
+}
+const D = /* @__PURE__ */ b({ computeWeightedLoss_: On });
+function Gn(e, a, n, r = N.SUM_BY_NONZERO_WEIGHTS) {
+  const t = u(e, "labels", "absoluteDifference"), s = u(a, "predictions", "absoluteDifference");
+  let o = null;
+  n != null && (o = u(n, "weights", "absoluteDifference")), B(t.shape, s.shape, "Error in absoluteDifference: ");
+  const i = ns(d(t, s));
+  return D(i, o, r);
+}
+const Bn = /* @__PURE__ */ b({ absoluteDifference_: Gn });
+function Dn(e, a, n, r, t = N.SUM_BY_NONZERO_WEIGHTS) {
+  const s = u(e, "labels", "cosineDistance"), o = u(a, "predictions", "cosineDistance");
+  let i = null;
+  r != null && (i = u(r, "weights", "cosineDistance")), B(s.shape, o.shape, "Error in cosineDistance: ");
+  const l = $(1), c = d(l, _(h(s, o), n, !0));
+  return D(c, i, t);
+}
+const Ln = /* @__PURE__ */ b({ cosineDistance_: Dn });
+function Wn(e, a, n, r = N.SUM_BY_NONZERO_WEIGHTS) {
+  let t = u(e, "labels", "hingeLoss");
+  const s = u(a, "predictions", "hingeLoss");
+  let o = null;
+  n != null && (o = u(n, "weights", "hingeLoss")), B(t.shape, s.shape, "Error in hingeLoss: ");
+  const i = $(1);
+  t = d(h($(2), t), i);
+  const l = fs(d(i, h(t, s)));
+  return D(l, o, r);
+}
+const Rn = /* @__PURE__ */ b({ hingeLoss_: Wn });
+function qn(e, a, n, r = 1, t = N.SUM_BY_NONZERO_WEIGHTS) {
+  const s = u(e, "labels", "huberLoss"), o = u(a, "predictions", "huberLoss");
+  let i = null;
+  n != null && (i = u(n, "weights", "huberLoss")), B(s.shape, o.shape, "Error in huberLoss: ");
+  const l = $(r), c = ns(d(o, s)), f = Q(c, l), m = d(c, f), E = G(h($(0.5), Ts(f)), h(l, m));
+  return D(E, i, t);
+}
+const zn = /* @__PURE__ */ b({ huberLoss_: qn });
+function Vn(e, a, n, r = 1e-7, t = N.SUM_BY_NONZERO_WEIGHTS) {
+  const s = u(e, "labels", "logLoss"), o = u(a, "predictions", "logLoss");
+  let i = null;
+  n != null && (i = u(n, "weights", "logLoss")), B(s.shape, o.shape, "Error in logLoss: ");
+  const l = $(1), c = $(r), f = C(h(s, is(G(o, c)))), m = h(d(l, s), is(G(d(l, o), c))), E = d(f, m);
+  return D(E, i, t);
+}
+const Cn = /* @__PURE__ */ b({ logLoss_: Vn });
+function Pn(e, a, n, r = N.SUM_BY_NONZERO_WEIGHTS) {
+  const t = u(e, "labels", "meanSquaredError"), s = u(a, "predictions", "meanSquaredError");
+  let o = null;
+  n != null && (o = u(n, "weights", "meanSquaredError")), B(t.shape, s.shape, "Error in meanSquaredError: ");
+  const i = Ws(t, s);
+  return D(i, o, r);
+}
+const Yn = /* @__PURE__ */ b({ meanSquaredError_: Pn });
+function vn(e, a) {
+  const n = u(e, "labels", "sigmoidCrossEntropyWithLogits"), r = u(a, "logits", "sigmoidCrossEntropyWithLogits");
+  B(n.shape, r.shape, "Error in sigmoidCrossEntropyWithLogits: ");
+  const t = fs(r), s = h(r, n), o = Rs(ss(C(ns(r))));
+  return G(d(t, s), o);
+}
+function jn(e, a, n, r = 0, t = N.SUM_BY_NONZERO_WEIGHTS) {
+  let s = u(e, "multiClassLabels", "sigmoidCrossEntropy");
+  const o = u(a, "logits", "sigmoidCrossEntropy");
+  let i = null;
+  if (n != null && (i = u(n, "weights", "sigmoidCrossEntropy")), B(s.shape, o.shape, "Error in sigmoidCrossEntropy: "), r > 0) {
+    const c = $(r), f = $(1), m = $(0.5);
+    s = G(h(s, d(f, c)), h(m, c));
+  }
+  const l = vn(s, o);
+  return D(l, i, t);
+}
+const Fn = /* @__PURE__ */ b({ sigmoidCrossEntropy_: jn });
+function Zn(e, a, n = -1) {
+  if (n === -1 && (n = a.rank - 1), n !== a.rank - 1)
+    throw Error(`Softmax cross entropy along a non-last dimension is not yet supported. Labels / logits was rank ${a.rank} and dim was ${n}`);
+  return Ms((t, s, o) => {
+    const l = vs(s, [n], !0), c = d(W(s, "float32"), l);
+    o([t, c]);
+    const f = C(h(c, t));
+    return { value: _(f, [n]), gradFunc: (g, y) => {
+      const [M, I] = y, A = js(g.shape, [n]);
+      return [
+        h(O(g, A), d(W(M, "float32"), ss(I))),
+        h(O(g, A), d(ss(I), W(M, "float32")))
+      ];
+    } };
+  })(e, a);
+}
+function Un(e, a, n, r = 0, t = N.SUM_BY_NONZERO_WEIGHTS) {
+  let s = u(e, "onehotLabels", "softmaxCrossEntropy");
+  const o = u(a, "logits", "softmaxCrossEntropy");
+  let i = null;
+  if (n != null && (i = u(n, "weights", "softmaxCrossEntropy")), B(s.shape, o.shape, "Error in softmaxCrossEntropy: "), r > 0) {
+    const c = $(r), f = $(1), m = $(s.shape[1]);
+    s = G(h(s, d(f, c)), S(c, m));
+  }
+  const l = Zn(s, o);
+  return D(l, i, t);
+}
+const Hn = /* @__PURE__ */ b({ softmaxCrossEntropy_: Un });
+const $t = {
+  flipLeftRight: sn,
+  grayscaleToRGB: tn,
+  resizeNearestNeighbor: qs,
+  resizeBilinear: zs,
+  rgbToGrayscale: on,
+  rotateWithOffset: an,
+  cropAndResize: Js,
+  nonMaxSuppression: ln,
+  nonMaxSuppressionAsync: pn,
+  nonMaxSuppressionWithScore: fn,
+  nonMaxSuppressionWithScoreAsync: bn,
+  nonMaxSuppressionPadded: gn,
+  nonMaxSuppressionPaddedAsync: $n,
+  threshold: Nn,
+  transform: kn
+}, yt = {
+  bandPart: Tn,
+  gramSchmidt: xn,
+  qr: wn
+}, _t = {
+  absoluteDifference: Bn,
+  computeWeightedLoss: D,
+  cosineDistance: Ln,
+  hingeLoss: Rn,
+  huberLoss: zn,
+  logLoss: Cn,
+  meanSquaredError: Yn,
+  sigmoidCrossEntropy: Fn,
+  softmaxCrossEntropy: Hn
+};
+export {
+  _t as a,
+  Ks as e,
+  $t as i,
+  yt as l
+};

package/dist/pack16-nQ6JaLo-.js

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

package/dist/patches/webgpu_backend.js

@@ -1,11 +1,10 @@
-import "../index-ZyQhjEPo.js";
-import "../webgpu_util-BBCnKm2X.js";
-import { W as c } from "../backend_webgpu-B0u2ndUn.js";
-import { compileProgram as l } from "./webgpu_program.js";
-import { m } from "../webgpu_program-Cigz-7RF.js";
-import { s as P, g as y, e as M, a as n } from "../tensor-DdQUJZlz.js";
-const b = (h, s) => {
-  const i = h.limits.maxComputeWorkgroupsPerDimension, t = s.dispatchLayout, a = s.dispatch;
+import { h as c, i as l, j as m, l as n } from "../index-DOvlwCh-.js";
+import "../webgpu_util-RxEF33Rj.js";
+import { W as P } from "../backend_webgpu-DE3ACOLx.js";
+import { compileProgram as y } from "./webgpu_program.js";
+import { m as M } from "../webgpu_program-DuOXPQol.js";
+const b = (o, s) => {
+  const i = o.limits.maxComputeWorkgroupsPerDimension, t = s.dispatchLayout, a = s.dispatch;
   if (a.every((r) => r <= i))
     return a;
   n(
@@ -18,32 +17,32 @@ const b = (h, s) => {
     () => "Total dispatch size exceeds WebGPU maximum."
   ), [e, e, e]) : [e, e, 1];
 };
-class U extends c {
+class z extends P {
   subgroupMaxSize;
   subgroupMinSize;
   constructor(s, i) {
     super(s, i), this.subgroupMaxSize = i?.subgroupMaxSize ?? 0, this.subgroupMinSize = i?.subgroupMinSize ?? 0;
   }
   runWebGPUProgram(s, i, t, a, e) {
-    if (e || (e = this.makeTensorInfo(s.outputShape, t)), P(e.shape) === 0)
-      return this.tensorMap.get(e.dataId).values = y(e.dtype, 0), e;
+    if (e || (e = this.makeTensorInfo(s.outputShape, t)), c(e.shape) === 0)
+      return this.tensorMap.get(e.dataId).values = l(e.dtype, 0), e;
     this.uploadToGPU(e.dataId), s.dispatch = b(this.device, s);
-    const r = i.map((o, p) => {
-      if (o.dtype === "complex64")
+    const r = i.map((h, p) => {
+      if (h.dtype === "complex64")
         throw new Error(
           "GPGPUProgram does not support complex64 input. For complex64 dtypes, please separate the program into real and imaginary parts."
         );
-      return this.uploadToGPU(o.dataId), {
+      return this.uploadToGPU(h.dataId), {
         // Returning dtype from tensorMap because it reflects dtype
         // of underlying buffer, rather than abstract dtype.
-        dtype: this.tensorMap.get(o.dataId).dtype,
-        shape: o.shape,
+        dtype: this.tensorMap.get(h.dataId).dtype,
+        shape: h.shape,
         name: s.variableNames[p]
       };
     });
-    s.shaderKey = m(s, r, e);
-    const d = M().getBool("WEBGPU_ENGINE_COMPILE_ONLY");
-    return s.shaderKey in this.pipelineCache || (this.pipelineCache[s.shaderKey] = l(
+    s.shaderKey = M(s, r, e);
+    const d = m().getBool("WEBGPU_ENGINE_COMPILE_ONLY");
+    return s.shaderKey in this.pipelineCache || (this.pipelineCache[s.shaderKey] = y(
       this.device,
       s,
       r,
@@ -53,5 +52,5 @@ class U extends c {
   }
 }
 export {
-  U as default
+  z as default
 };

package/dist/patches/webgpu_base.js

@@ -1,4 +1,4 @@
-import { f as n } from "../index-ZyQhjEPo.js";
+import { f as n } from "../index-DOvlwCh-.js";
 import p from "./webgpu_backend.js";
 function c(a) {
   n(