@genai-fi/nanogpt 0.10.1 → 0.10.3

package/dist/slice-BfEGSH82.js

@@ -0,0 +1,12 @@
+import { A as c, B as e, E as a, S as l } from "./index-DOvlwCh-.js";
+function p(r, n, o) {
+  const s = e(r, "x", "slice", "string_or_numeric");
+  if (s.rank === 0)
+    throw new Error("Slicing scalar is not possible");
+  const t = { x: s }, i = { begin: n, size: o };
+  return a.runKernel(l, t, i);
+}
+const x = /* @__PURE__ */ c({ slice_: p });
+export {
+  x as s
+};

package/dist/{slice_util-DtEldBfK.js → slice_util-uTKwiEpW.js}

@@ -1,4 +1,4 @@
-import { a as E, k as x } from "./tensor-DdQUJZlz.js";
+import { l as E, aa as x } from "./index-DOvlwCh-.js";
 const N = -2, L = -1;
 function P(n, e, i) {
   const r = n.shape.length;

package/dist/{softmax-ZHVebtR1.js → softmax-CA5jFsLR.js}

@@ -1,13 +1,12 @@
-import { A as r, B as f, E as i } from "./index-ZyQhjEPo.js";
-import { S as e } from "./tensor_util-DV-FP5Q3.js";
+import { A as r, B as f, E as e, Q as i } from "./index-DOvlwCh-.js";
 function l(s, o = -1) {
   const t = f(s, "logits", "softmax", "float32");
   if (o === -1 && (o = t.rank - 1), o !== t.rank - 1)
     throw Error(`Softmax along a non-last dimension is not yet supported. Logits was rank ${t.rank} and dim was ${o}`);
   const n = { logits: t }, a = { dim: o };
-  return i.runKernel(e, n, a);
+  return e.runKernel(i, n, a);
 }
-const c = /* @__PURE__ */ r({ softmax_: l });
+const p = /* @__PURE__ */ r({ softmax_: l });
 export {
-  c as s
+  p as s
 };

package/dist/split-CVLc0w--.js

@@ -0,0 +1,9 @@
+import { A as p, B as i, E as a, U as c } from "./index-DOvlwCh-.js";
+function e(t, s, n = 0) {
+  const o = { x: i(t, "x", "split") }, r = { numOrSizeSplits: s, axis: n };
+  return a.runKernel(c, o, r);
+}
+const u = /* @__PURE__ */ p({ split_: e });
+export {
+  u as s
+};

package/dist/squeeze-C7Z2srUo.js

@@ -0,0 +1,10 @@
+import { A as o, B as n, V as a } from "./index-DOvlwCh-.js";
+import { r as t } from "./reshape-ByE68wS9.js";
+function p(s, r) {
+  const e = n(s, "x", "squeeze", "string_or_numeric");
+  return t(e, a(e.shape, r).newShape);
+}
+const i = /* @__PURE__ */ o({ squeeze_: p });
+export {
+  i as s
+};

package/dist/stack-Cf4n9h0N.js

@@ -0,0 +1,11 @@
+import { A as e, G as c, l as n, E as k, W as i } from "./index-DOvlwCh-.js";
+function u(r, t = 0) {
+  const s = c(r, "tensors", "stack", "string_or_numeric");
+  n(s.length >= 1, () => "Pass at least one tensor to tf.stack"), s.length > 0 && n(t <= s[0].rank, () => "Axis must be <= rank of the tensor");
+  const o = s, a = { axis: t };
+  return k.runKernel(i, o, a);
+}
+const l = /* @__PURE__ */ e({ stack_: u });
+export {
+  l as s
+};

package/dist/step-CINUs5QB.js

@@ -0,0 +1,261 @@
+import { l as _, aG as P, A as k, B as M, E as v, aH as F, aI as J, aJ as X, aK as q, aL as Q, aM as Y } from "./index-DOvlwCh-.js";
+function it(t, n, e, o, s = "NHWC", f) {
+  const l = t[3], r = [...n, l], c = nt(s);
+  return B(t, r, e, f, o, null, null, c);
+}
+function ft(t, n, e, o, s, f, l = "channelsLast") {
+  const [r, c] = T(n);
+  let u;
+  if (l === "channelsLast")
+    u = [r, c, t[3], t[3]];
+  else if (l === "channelsFirst")
+    u = [r, c, t[1], t[1]];
+  else
+    throw new Error(`Unknown dataFormat ${l}`);
+  return B(t, u, e, o, s, f, !1, l);
+}
+function ht(t, n, e, o, s, f, l = "NDHWC") {
+  const [r, c, u] = K(n);
+  let h, i;
+  if (l === "NDHWC")
+    i = "channelsLast", h = [r, c, u, t[4], t[4]];
+  else if (l === "NCDHW")
+    i = "channelsFirst", h = [r, c, u, t[1], t[1]];
+  else
+    throw new Error(`Unknown dataFormat ${l}`);
+  return Z(t, h, e, o, s, !1, i, f);
+}
+function B(t, n, e, o, s, f, l = !1, r = "channelsLast") {
+  let [c, u, h, i] = [-1, -1, -1, -1];
+  if (r === "channelsLast")
+    [c, u, h, i] = t;
+  else if (r === "channelsFirst")
+    [c, i, u, h] = t;
+  else
+    throw new Error(`Unknown dataFormat ${r}`);
+  const [a, p, , $] = n, [w, g] = T(e), [x, y] = T(o), L = A(a, x), b = A(p, y), { padInfo: C, outHeight: E, outWidth: D } = d(s, u, h, w, g, L, b, f, r), I = l ? $ * i : $;
+  let m;
+  return r === "channelsFirst" ? m = [c, I, E, D] : r === "channelsLast" && (m = [c, E, D, I]), {
+    batchSize: c,
+    dataFormat: r,
+    inHeight: u,
+    inWidth: h,
+    inChannels: i,
+    outHeight: E,
+    outWidth: D,
+    outChannels: I,
+    padInfo: C,
+    strideHeight: w,
+    strideWidth: g,
+    filterHeight: a,
+    filterWidth: p,
+    effectiveFilterHeight: L,
+    effectiveFilterWidth: b,
+    dilationHeight: x,
+    dilationWidth: y,
+    inShape: t,
+    outShape: m,
+    filterShape: n
+  };
+}
+function Z(t, n, e, o, s, f = !1, l = "channelsLast", r) {
+  let [c, u, h, i, a] = [-1, -1, -1, -1, -1];
+  if (l === "channelsLast")
+    [c, u, h, i, a] = t;
+  else if (l === "channelsFirst")
+    [c, a, u, h, i] = t;
+  else
+    throw new Error(`Unknown dataFormat ${l}`);
+  const [p, $, w, , g] = n, [x, y, L] = K(e), [b, C, E] = K(o), D = A(p, b), I = A($, C), m = A(w, E), { padInfo: G, outDepth: N, outHeight: R, outWidth: W } = tt(s, u, h, i, x, y, L, D, I, m, r), H = f ? g * a : g;
+  let O;
+  return l === "channelsFirst" ? O = [c, H, N, R, W] : l === "channelsLast" && (O = [c, N, R, W, H]), {
+    batchSize: c,
+    dataFormat: l,
+    inDepth: u,
+    inHeight: h,
+    inWidth: i,
+    inChannels: a,
+    outDepth: N,
+    outHeight: R,
+    outWidth: W,
+    outChannels: H,
+    padInfo: G,
+    strideDepth: x,
+    strideHeight: y,
+    strideWidth: L,
+    filterDepth: p,
+    filterHeight: $,
+    filterWidth: w,
+    effectiveFilterDepth: D,
+    effectiveFilterHeight: I,
+    effectiveFilterWidth: m,
+    dilationDepth: b,
+    dilationHeight: C,
+    dilationWidth: E,
+    inShape: t,
+    outShape: O,
+    filterShape: n
+  };
+}
+function z(t, n, e, o, s) {
+  o == null && (o = j(t, n, e));
+  const f = t[0], l = t[1], r = U((f - n + 2 * o) / e + 1, s), c = U((l - n + 2 * o) / e + 1, s);
+  return [r, c];
+}
+function S(t, n, e, o, s, f) {
+  s == null && (s = j(t, n[0], o[0]));
+  const l = [0, 0, 0, e];
+  for (let r = 0; r < 3; r++)
+    t[r] + 2 * s >= n[r] && (l[r] = U((t[r] - n[r] + 2 * s) / o[r] + 1, f));
+  return l;
+}
+function j(t, n, e, o = 1) {
+  const s = A(n, o);
+  return Math.floor((t[0] * (e - 1) - e + s) / 2);
+}
+function T(t) {
+  return typeof t == "number" ? [t, t, t] : t.length === 2 ? [t[0], t[1], 1] : t;
+}
+function K(t) {
+  return typeof t == "number" ? [t, t, t] : t;
+}
+function A(t, n) {
+  return n <= 1 ? t : t + (t - 1) * (n - 1);
+}
+function d(t, n, e, o, s, f, l, r, c) {
+  let u, h, i;
+  if (typeof t == "number") {
+    u = { top: t, bottom: t, left: t, right: t, type: t === 0 ? "VALID" : "NUMBER" };
+    const p = z([n, e], f, o, t, r);
+    h = p[0], i = p[1];
+  } else if (t === "same") {
+    h = Math.ceil(n / o), i = Math.ceil(e / s);
+    const a = Math.max(0, (h - 1) * o + f - n), p = Math.max(0, (i - 1) * s + l - e), $ = Math.floor(a / 2), w = a - $, g = Math.floor(p / 2), x = p - g;
+    u = { top: $, bottom: w, left: g, right: x, type: "SAME" };
+  } else if (t === "valid")
+    u = { top: 0, bottom: 0, left: 0, right: 0, type: "VALID" }, h = Math.ceil((n - f + 1) / o), i = Math.ceil((e - l + 1) / s);
+  else if (typeof t == "object") {
+    const a = c === "channelsLast" ? t[1][0] : t[2][0], p = c === "channelsLast" ? t[1][1] : t[2][1], $ = c === "channelsLast" ? t[2][0] : t[3][0], w = c === "channelsLast" ? t[2][1] : t[3][1];
+    u = { top: a, bottom: p, left: $, right: w, type: a === 0 && p === 0 && $ === 0 && w === 0 ? "VALID" : "EXPLICIT" }, h = U((n - f + a + p) / o + 1, r), i = U((e - l + $ + w) / s + 1, r);
+  } else
+    throw Error(`Unknown padding parameter: ${t}`);
+  return { padInfo: u, outHeight: h, outWidth: i };
+}
+function tt(t, n, e, o, s, f, l, r, c, u, h) {
+  let i, a, p, $;
+  if (t === "valid" && (t = 0), typeof t == "number") {
+    i = {
+      top: t,
+      bottom: t,
+      left: t,
+      right: t,
+      front: t,
+      back: t,
+      type: t === 0 ? "VALID" : "NUMBER"
+    };
+    const g = S([n, e, o, 1], [r, c, u], 1, [s, f, l], t, h);
+    a = g[0], p = g[1], $ = g[2];
+  } else if (t === "same") {
+    a = Math.ceil(n / s), p = Math.ceil(e / f), $ = Math.ceil(o / l);
+    const w = (a - 1) * s + r - n, g = (p - 1) * f + c - e, x = ($ - 1) * l + u - o, y = Math.floor(w / 2), L = w - y, b = Math.floor(g / 2), C = g - b, E = Math.floor(x / 2), D = x - E;
+    i = { top: b, bottom: C, left: E, right: D, front: y, back: L, type: "SAME" };
+  } else
+    throw Error(`Unknown padding parameter: ${t}`);
+  return { padInfo: i, outDepth: a, outHeight: p, outWidth: $ };
+}
+function U(t, n) {
+  if (!n)
+    return Math.trunc(t);
+  switch (n) {
+    case "round":
+      return Math.round(t);
+    case "ceil":
+      return Math.ceil(t);
+    case "floor":
+      return Math.floor(t);
+    default:
+      throw new Error(`Unknown roundingMode ${n}`);
+  }
+}
+function V(t) {
+  const [n, e, o] = T(t);
+  return n === 1 && e === 1 && o === 1;
+}
+function at(t, n) {
+  return V(t) || V(n);
+}
+function pt(t) {
+  return T(t).every((n) => n > 0);
+}
+function nt(t) {
+  if (t === "NHWC")
+    return "channelsLast";
+  if (t === "NCHW")
+    return "channelsFirst";
+  throw new Error(`Unknown dataFormat ${t}`);
+}
+function $t(t, n, e) {
+  if (e != null) {
+    if (typeof n == "string")
+      throw Error(`Error in ${t}: pad must be an integer when using dimRoundingMode ${e} but got pad ${n}.`);
+    if (typeof n == "number")
+      _(P(n), () => `Error in ${t}: pad must be an integer when using dimRoundingMode ${e} but got pad ${n}.`);
+    else if (typeof n == "object")
+      n.forEach((o) => {
+        o.forEach((s) => {
+          _(P(s), () => `Error in ${t}: pad must be an integer when using dimRoundingMode ${e} but got pad ${s}.`);
+        });
+      });
+    else
+      throw Error(`Error in ${t}: Unknown padding parameter: ${n}`);
+  }
+}
+function et(t) {
+  const e = { x: M(t, "x", "sigmoid", "float32") };
+  return v.runKernel(F, e);
+}
+const gt = /* @__PURE__ */ k({ sigmoid_: et });
+function ot(t) {
+  const e = { x: M(t, "x", "elu", "float32") };
+  return v.runKernel(J, e);
+}
+const wt = /* @__PURE__ */ k({ elu_: ot });
+function st(t, n = 0.2) {
+  const o = { x: M(t, "x", "leakyRelu") }, s = { alpha: n };
+  return v.runKernel(X, o, s);
+}
+const xt = /* @__PURE__ */ k({ leakyRelu_: st });
+function rt(t, n) {
+  const e = M(t, "x", "prelu"), o = M(n, "alpha", "prelu"), s = { x: e, alpha: o };
+  return v.runKernel(q, s);
+}
+const Et = /* @__PURE__ */ k({ prelu_: rt });
+function lt(t) {
+  const e = { x: M(t, "x", "relu6") };
+  return v.runKernel(Q, e);
+}
+const yt = /* @__PURE__ */ k({ relu6_: lt });
+function ct(t, n = 0) {
+  const o = { x: M(t, "x", "step") }, s = { alpha: n };
+  return v.runKernel(Y, o, s);
+}
+const bt = /* @__PURE__ */ k({ step_: ct });
+export {
+  bt as a,
+  B as b,
+  $t as c,
+  Z as d,
+  wt as e,
+  j as f,
+  it as g,
+  ft as h,
+  ht as i,
+  nt as j,
+  at as k,
+  xt as l,
+  pt as m,
+  Et as p,
+  yt as r,
+  gt as s,
+  V as t
+};

package/dist/sum-DWAtNGez.js

@@ -0,0 +1,11 @@
+import { A as e, B as u, X as c, E as l, Y as m } from "./index-DOvlwCh-.js";
+function i(t, n = null, o = !1) {
+  let s = u(t, "x", "sum");
+  s.dtype === "bool" && (s = c(s, "int32"));
+  const r = { x: s }, a = { axis: n, keepDims: o };
+  return l.runKernel(m, r, a);
+}
+const f = /* @__PURE__ */ e({ sum_: i });
+export {
+  f as s
+};

package/dist/tensor-DJoc7gJU.js

@@ -0,0 +1,8 @@
+import { a0 as o, a1 as t } from "./index-DOvlwCh-.js";
+function f(r, n, e) {
+  const a = o(r, e);
+  return t(r, n, a, e);
+}
+export {
+  f as t
+};

package/dist/tensor1d-D11P_7Dp.js

@@ -0,0 +1,11 @@
+import { $ as n, a0 as o, a1 as s } from "./index-DOvlwCh-.js";
+function h(r, e) {
+  n(r);
+  const a = o(r, e);
+  if (a.length !== 1)
+    throw new Error("tensor1d() requires values to be a flat/TypedArray");
+  return s(r, null, a, e);
+}
+export {
+  h as t
+};

package/dist/{tensor2d-G4Ys2GxX.js → tensor2d-Bs9wZRc7.js}

@@ -1,15 +1,14 @@
-import { x as t, y as s } from "./index-ZyQhjEPo.js";
-import { c as a } from "./tensor-DdQUJZlz.js";
-function f(o, r, n) {
-  if (a(o), r != null && r.length !== 2)
+import { $ as t, a0 as a, a1 as s } from "./index-DOvlwCh-.js";
+function i(n, r, o) {
+  if (t(n), r != null && r.length !== 2)
     throw new Error("tensor2d() requires shape to have two numbers");
-  const e = t(o, n);
+  const e = a(n, o);
   if (e.length !== 2 && e.length !== 1)
     throw new Error("tensor2d() requires values to be number[][] or flat/TypedArray");
   if (e.length === 1 && r == null)
     throw new Error("tensor2d() requires shape to be provided when `values` are a flat/TypedArray");
-  return s(o, r, e, n);
+  return s(n, r, e, o);
 }
 export {
-  f as t
+  i as t
 };

package/dist/{tensor4d-B8roDgtc.js → tensor4d-BARPdTaS.js}

@@ -1,15 +1,14 @@
-import { x as t, y as a } from "./index-ZyQhjEPo.js";
-import { c as s } from "./tensor-DdQUJZlz.js";
-function f(o, r, n) {
-  if (s(o), r != null && r.length !== 4)
+import { $ as t, a0 as a, a1 as s } from "./index-DOvlwCh-.js";
+function i(n, r, o) {
+  if (t(n), r != null && r.length !== 4)
     throw new Error("tensor4d() requires shape to have four numbers");
-  const e = t(o, n);
+  const e = a(n, o);
   if (e.length !== 4 && e.length !== 1)
     throw new Error("tensor4d() requires values to be number[][][][] or flat/TypedArray");
   if (e.length === 1 && r == null)
     throw new Error("tensor4d() requires shape to be provided when `values` are a flat array");
-  return a(o, r, e, n);
+  return s(n, r, e, o);
 }
 export {
-  f as t
+  i as t
 };