@genai-fi/nanogpt 0.10.2 → 0.11.0

package/dist/slice-Aqy7KbJh.js

@@ -0,0 +1,12 @@
+import { q as c, u as e, E as a, S as l } from "./index-D0RBWjq8.js";
+function u(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_: u });
+export {
+  x as s
+};

package/dist/{slice_util-DyjSAD0u.js → slice_util-D8CQRenR.js}

@@ -1,4 +1,4 @@
-import { a as E, k as x } from "./tensor-CzmOBsdf.js";
+import { y as E, a6 as x } from "./index-D0RBWjq8.js";
 const N = -2, L = -1;
 function P(n, e, i) {
   const r = n.shape.length;
@@ -157,7 +157,7 @@ function q(n, e, i, r, t, o, a, f, c) {
     endValid: !1
   };
   J(g, s);
-  let u = !0, p = !0, M = !0;
+  let u = !0, p = !0, y = !0;
   const I = [], w = [];
   for (let l = 0; l < n.length; ++l) {
     if (s.strides[l] === 0)
@@ -173,8 +173,8 @@ function q(n, e, i, r, t, o, a, f, c) {
     ];
     if (m && s.strides[l] <= 0)
       throw Error("only stride 1 allowed on non-range indexing.");
-    M = M && s.strides[l] === 1;
-    const y = !!(s.beginMask & 1 << l && s.endMask & 1 << l);
+    y = y && s.strides[l] === 1;
+    const M = !!(s.beginMask & 1 << l && s.endMask & 1 << l);
     if (s.beginValid && s.endValid) {
       if (m) {
         const G = s.begin[l] < 0 ? d + s.begin[l] : s.begin[l];
@@ -185,9 +185,9 @@ function q(n, e, i, r, t, o, a, f, c) {
       const b = s.strides[l] === 1 && s.begin[l] === 0 && s.end[l] === d;
       u = u && b, p = p && (l === 0 && s.strides[l] === 1 || b);
     } else
-      u = u && s.strides[l] === 1 && y, p = p && (l === 0 && s.strides[l] === 1 || y);
+      u = u && s.strides[l] === 1 && M, p = p && (l === 0 && s.strides[l] === 1 || M);
     let A, k = !1;
-    if (s.beginValid && s.endValid ? (A = s.end[l] - s.begin[l], k = !0) : m ? (A = 1, k = !0) : y && d >= 0 && (s.strides[l] < 0 ? A = -d : A = d, k = !0), k) {
+    if (s.beginValid && s.endValid ? (A = s.end[l] - s.begin[l], k = !0) : m ? (A = 1, k = !0) : M && d >= 0 && (s.strides[l] < 0 ? A = -d : A = d, k = !0), k) {
       let b;
       A === 0 || A < 0 != s.strides[l] < 0 ? b = 0 : b = Math.trunc(A / s.strides[l]) + (A % s.strides[l] !== 0 ? 1 : 0), I.push(b);
     } else
@@ -202,7 +202,7 @@ function q(n, e, i, r, t, o, a, f, c) {
     finalShape: w,
     isIdentity: u,
     sliceDim0: p,
-    isSimpleSlice: M,
+    isSimpleSlice: y,
     begin: s.begin,
     end: s.end,
     strides: s.strides

package/dist/{softmax-C9JQEtnO.js → softmax-faLoUZVT.js}

@@ -1,13 +1,12 @@
-import { A as r, B as f, E as i } from "./index-D6Q1lPZO.js";
-import { S as e } from "./tensor_util-DfwaWayG.js";
+import { q as r, u as f, E as e, J as i } from "./index-D0RBWjq8.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-BNz5jcGc.js

@@ -0,0 +1,9 @@
+import { q as p, u as i, E as a, K as c } from "./index-D0RBWjq8.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 x = /* @__PURE__ */ p({ split_: e });
+export {
+  x as s
+};

package/dist/squeeze--YMgaAAf.js

@@ -0,0 +1,10 @@
+import { q as o, u as n, L as a } from "./index-D0RBWjq8.js";
+import { r as t } from "./reshape-CkjKPPqB.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-WJK22CFn.js

@@ -0,0 +1,11 @@
+import { q as e, z as c, y as n, E as k, P as i } from "./index-D0RBWjq8.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-dXR33iOg.js

@@ -0,0 +1,261 @@
+import { y as _, aG as P, q as A, u as M, E as v, aH as q, aI as F, aJ as J, aK as X, aL as Q, aM as Y } from "./index-D0RBWjq8.js";
+function it(t, n, e, o, s = "NHWC", f) {
+  const l = t[3], r = [...n, l], c = nt(s);
+  return j(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 j(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 j(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, E] = T(o), L = k(a, x), b = k(p, E), { padInfo: C, outHeight: y, outWidth: D } = d(s, u, h, w, g, L, b, f, r), I = l ? $ * i : $;
+  let m;
+  return r === "channelsFirst" ? m = [c, I, y, D] : r === "channelsLast" && (m = [c, y, D, I]), {
+    batchSize: c,
+    dataFormat: r,
+    inHeight: u,
+    inWidth: h,
+    inChannels: i,
+    outHeight: y,
+    outWidth: D,
+    outChannels: I,
+    padInfo: C,
+    strideHeight: w,
+    strideWidth: g,
+    filterHeight: a,
+    filterWidth: p,
+    effectiveFilterHeight: L,
+    effectiveFilterWidth: b,
+    dilationHeight: x,
+    dilationWidth: E,
+    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, E, L] = K(e), [b, C, y] = K(o), D = k(p, b), I = k($, C), m = k(w, y), { padInfo: G, outDepth: N, outHeight: R, outWidth: W } = tt(s, u, h, i, x, E, 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: E,
+    strideWidth: L,
+    filterDepth: p,
+    filterHeight: $,
+    filterWidth: w,
+    effectiveFilterDepth: D,
+    effectiveFilterHeight: I,
+    effectiveFilterWidth: m,
+    dilationDepth: b,
+    dilationHeight: C,
+    dilationWidth: y,
+    inShape: t,
+    outShape: O,
+    filterShape: n
+  };
+}
+function z(t, n, e, o, s) {
+  o == null && (o = B(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 = B(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 B(t, n, e, o = 1) {
+  const s = k(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 k(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, E = Math.floor(w / 2), L = w - E, b = Math.floor(g / 2), C = g - b, y = Math.floor(x / 2), D = x - y;
+    i = { top: b, bottom: C, left: y, right: D, front: E, 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(q, e);
+}
+const gt = /* @__PURE__ */ A({ sigmoid_: et });
+function ot(t) {
+  const e = { x: M(t, "x", "elu", "float32") };
+  return v.runKernel(F, e);
+}
+const wt = /* @__PURE__ */ A({ elu_: ot });
+function st(t, n = 0.2) {
+  const o = { x: M(t, "x", "leakyRelu") }, s = { alpha: n };
+  return v.runKernel(J, o, s);
+}
+const xt = /* @__PURE__ */ A({ 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(X, s);
+}
+const yt = /* @__PURE__ */ A({ prelu_: rt });
+function lt(t) {
+  const e = { x: M(t, "x", "relu6") };
+  return v.runKernel(Q, e);
+}
+const Et = /* @__PURE__ */ A({ 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__ */ A({ step_: ct });
+export {
+  bt as a,
+  j as b,
+  $t as c,
+  Z as d,
+  wt as e,
+  B as f,
+  it as g,
+  ft as h,
+  ht as i,
+  nt as j,
+  at as k,
+  xt as l,
+  pt as m,
+  yt as p,
+  Et as r,
+  gt as s,
+  V as t
+};

package/dist/sum-BdplSvq_.js

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

package/dist/{tensor-0r5yOo2R.js → tensor-BQqrDvpx.js}

@@ -1,4 +1,4 @@
-import { x as t, y as a } from "./index-D6Q1lPZO.js";
+import { Y as t, Z as a } from "./index-D0RBWjq8.js";
 function f(r, n, e) {
   const o = t(r, e);
   return a(r, n, o, e);

package/dist/tensor1d-LxP9asMm.js

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

package/dist/{tensor2d-CSB4KOb0.js → tensor2d-BN1sSfQO.js}

@@ -1,15 +1,14 @@
-import { x as t, y as s } from "./index-D6Q1lPZO.js";
-import { c as a } from "./tensor-CzmOBsdf.js";
-function f(o, r, n) {
-  if (a(o), r != null && r.length !== 2)
+import { X as t, Y as s, Z as a } from "./index-D0RBWjq8.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 = s(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 a(n, r, e, o);
 }
 export {
-  f as t
+  i as t
 };

package/dist/{tensor4d-D7bLqGqz.js → tensor4d-DVwr7pLF.js}

@@ -1,15 +1,14 @@
-import { x as t, y as a } from "./index-D6Q1lPZO.js";
-import { c as s } from "./tensor-CzmOBsdf.js";
-function f(o, r, n) {
-  if (s(o), r != null && r.length !== 4)
+import { X as t, Y as a, Z as s } from "./index-D0RBWjq8.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
 };