@genai-fi/nanogpt 0.9.0 → 0.10.0

package/dist/tensor-f35l8Odg.js

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

package/dist/tensor1d-CeZuc-Rv.js

@@ -0,0 +1,12 @@
+import { x as n, y as t } from "./index-ZyQhjEPo.js";
+import { c as s } from "./tensor-DdQUJZlz.js";
+function p(r, e) {
+  s(r);
+  const o = n(r, e);
+  if (o.length !== 1)
+    throw new Error("tensor1d() requires values to be a flat/TypedArray");
+  return t(r, null, o, e);
+}
+export {
+  p as t
+};

package/dist/tensor2d-G4Ys2GxX.js

@@ -0,0 +1,15 @@
+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)
+    throw new Error("tensor2d() requires shape to have two numbers");
+  const e = t(o, n);
+  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);
+}
+export {
+  f as t
+};

package/dist/tensor4d-B8roDgtc.js

@@ -0,0 +1,15 @@
+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)
+    throw new Error("tensor4d() requires shape to have four numbers");
+  const e = t(o, n);
+  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);
+}
+export {
+  f as t
+};

package/dist/tensor_util-DV-FP5Q3.js

@@ -0,0 +1,523 @@
+import { e as g, F, x as v, G as D, b as M, T as w } from "./tensor-DdQUJZlz.js";
+const A = 1e-7, G = 1e-4;
+class z {
+  constructor(s, o) {
+    this.backend = s, this.dataMover = o, this.data = /* @__PURE__ */ new WeakMap(), this.dataIdsCount = 0;
+  }
+  get(s) {
+    return this.data.has(s) || this.dataMover.moveData(this.backend, s), this.data.get(s);
+  }
+  set(s, o) {
+    this.dataIdsCount++, this.data.set(s, o);
+  }
+  has(s) {
+    return this.data.has(s);
+  }
+  delete(s) {
+    return this.dataIdsCount--, this.data.delete(s);
+  }
+  numDataIds() {
+    return this.dataIdsCount;
+  }
+}
+class K {
+  refCount(s) {
+    return d("refCount");
+  }
+  incRef(s) {
+    return d("incRef");
+  }
+  timerAvailable() {
+    return !0;
+  }
+  time(s) {
+    return d("time");
+  }
+  read(s) {
+    return d("read");
+  }
+  readSync(s) {
+    return d("readSync");
+  }
+  readToGPU(s, o) {
+    return d("readToGPU");
+  }
+  numDataIds() {
+    return d("numDataIds");
+  }
+  disposeData(s, o) {
+    return d("disposeData");
+  }
+  write(s, o, c) {
+    return d("write");
+  }
+  move(s, o, c, a, r) {
+    return d("move");
+  }
+  createTensorFromGPUData(s, o, c) {
+    return d("createTensorFromGPUData");
+  }
+  memory() {
+    return d("memory");
+  }
+  /** Returns the highest precision for floats in bits (e.g. 16 or 32) */
+  floatPrecision() {
+    return d("floatPrecision");
+  }
+  /** Returns the smallest representable number.  */
+  epsilon() {
+    return this.floatPrecision() === 32 ? A : G;
+  }
+  dispose() {
+    return d("dispose");
+  }
+}
+function d(t) {
+  throw new Error(`'${t}' not yet implemented or not found in the registry. This kernel may not be supported by the tfjs backend you have chosen`);
+}
+const _ = "Abs", U = "Acos", W = "Acosh", j = "Add", H = "AddN", X = "All", Y = "Any", Z = "ArgMax", J = "ArgMin", Q = "Asin", tt = "Asinh", st = "Atan", ot = "Atanh", et = "Atan2", nt = "AvgPool", at = "AvgPoolGrad", rt = "AvgPool3D", ct = "AvgPool3DGrad", it = "BatchMatMul", lt = "BatchToSpaceND", ut = "Bincount", pt = "BitwiseAnd", dt = "BroadcastTo", ft = "BroadcastArgs", ht = "Cast", gt = "Ceil", mt = "ClipByValue", bt = "Complex", St = "ComplexAbs", Dt = "Concat", Rt = "Conv2D", Tt = "Conv2DBackpropFilter", kt = "Conv2DBackpropInput", Nt = "Conv3D", xt = "Conv3DBackpropFilterV2", Pt = "Conv3DBackpropInputV2", vt = "Cos", Ct = "Cosh", Ft = "Cumprod", yt = "Cumsum", It = "CropAndResize", Bt = "DenseBincount", Et = "DepthToSpace", Mt = "DepthwiseConv2dNative", wt = "DepthwiseConv2dNativeBackpropFilter", At = "DepthwiseConv2dNativeBackpropInput", Gt = "Diag", Lt = "Dilation2D", $t = "Dilation2DBackpropInput", Ot = "Dilation2DBackpropFilter", qt = "Draw", Vt = "RealDiv", zt = "Einsum", Kt = "Elu", _t = "EluGrad", Ut = "Erf", Wt = "Equal", jt = "Exp", Ht = "ExpandDims", Xt = "Expm1", Yt = "FFT", Zt = "Fill", Jt = "FlipLeftRight", Qt = "Floor", ts = "FloorDiv", ss = "FusedBatchNorm", os = "GatherV2", es = "GatherNd", ns = "Greater", as = "GreaterEqual", rs = "Identity", cs = "IFFT", is = "Imag", ls = "IsFinite", us = "IsInf", ps = "IsNan", ds = "LeakyRelu", fs = "Less", hs = "LessEqual", gs = "LinSpace", ms = "Log", bs = "Log1p", Ss = "LogicalAnd", Ds = "LogicalNot", Rs = "LogicalOr", Ts = "LogSoftmax", ks = "LRN", Ns = "LRNGrad", xs = "Max", Ps = "Maximum", vs = "MaxPool", Cs = "MaxPoolGrad", Fs = "MaxPool3D", ys = "MaxPool3DGrad", Is = "MaxPoolWithArgmax", Bs = "Mean", Es = "Min", Ms = "Minimum", ws = "MirrorPad", As = "Mod", Gs = "Multinomial", Ls = "Multiply", $s = "Neg", Os = "NotEqual", qs = "NonMaxSuppressionV3", Vs = "NonMaxSuppressionV4", zs = "NonMaxSuppressionV5", Ks = "OnesLike", _s = "OneHot", Us = "Pack", Ws = "PadV2", js = "Pow", Hs = "Prelu", Xs = "Prod", Ys = "RaggedGather", Zs = "RaggedRange", Js = "RaggedTensorToTensor", Qs = "Range", to = "Real", so = "Reciprocal", oo = "Relu", eo = "Reshape", no = "ResizeNearestNeighbor", ao = "ResizeNearestNeighborGrad", ro = "ResizeBilinear", co = "ResizeBilinearGrad", io = "Relu6", lo = "Reverse", uo = "Round", po = "Rsqrt", fo = "ScatterNd", ho = "TensorScatterUpdate", go = "SearchSorted", mo = "Select", bo = "Selu", So = "Slice", Do = "Sin", Ro = "Sinh", To = "Sign", ko = "Sigmoid", No = "Softplus", xo = "Sqrt", Po = "Sum", vo = "SpaceToBatchND", Co = "SplitV", Fo = "Softmax", yo = "SparseFillEmptyRows", Io = "SparseReshape", Bo = "SparseSegmentMean", Eo = "SparseSegmentSum", Mo = "SparseToDense", wo = "SquaredDifference", Ao = "Square", Go = "StaticRegexReplace", Lo = "StridedSlice", $o = "StringNGrams", Oo = "StringSplit", qo = "StringToHashBucketFast", Vo = "Sub", zo = "Tan", Ko = "Tanh", _o = "Tile", Uo = "TopK", Wo = "Transform", jo = "Transpose", Ho = "Unique", Xo = "Unpack", Yo = "UnsortedSegmentSum", Zo = "ZerosLike", Jo = "Step", Qo = "FromPixels", te = "RotateWithOffset", se = "_FusedMatMul", oe = "FusedConv2D", ee = "FusedDepthwiseConv2D";
+function y(...t) {
+  g().getBool("IS_TEST") || g().getBool("PROD") || console.warn(...t);
+}
+function ne(...t) {
+  g().getBool("IS_TEST") || g().getBool("PROD") || console.log(...t);
+}
+const S = F("kernelRegistry", () => /* @__PURE__ */ new Map()), R = F("gradRegistry", () => /* @__PURE__ */ new Map());
+function ae(t, s) {
+  const o = I(t, s);
+  return S.get(o);
+}
+function re(t) {
+  return R.get(t);
+}
+function ce(t) {
+  const s = S.entries(), o = [];
+  for (; ; ) {
+    const { done: c, value: a } = s.next();
+    if (c)
+      break;
+    const [r, l] = a, [p] = r.split("_");
+    p === t && o.push(l);
+  }
+  return o;
+}
+function ie(t) {
+  const { kernelName: s, backendName: o } = t, c = I(s, o);
+  S.has(c) && y(`The kernel '${s}' for backend '${o}' is already registered`), S.set(c, t);
+}
+function le(t) {
+  const { kernelName: s } = t;
+  R.has(s) && g().getBool("DEBUG") && y(`Overriding the gradient for '${s}'`), R.set(s, t);
+}
+function I(t, s) {
+  return `${s}_${t}`;
+}
+class ue {
+  constructor(s, o) {
+    this.backendTimer = s, this.logger = o, o == null && (this.logger = new $());
+  }
+  profileKernel(s, o, c) {
+    let a;
+    const r = () => {
+      a = c();
+    };
+    let l;
+    const p = v();
+    if (this.backendTimer.timerAvailable())
+      l = this.backendTimer.time(r);
+    else {
+      r();
+      for (const e of a)
+        e.dataSync();
+      l = Promise.resolve({ kernelMs: v() - p });
+    }
+    if (g().getBool("CHECK_COMPUTATION_FOR_ERRORS"))
+      for (let e = 0; e < a.length; e++) {
+        const i = a[e];
+        i.data().then((u) => {
+          L(u, i.dtype, s);
+        });
+      }
+    return {
+      kernelName: s,
+      outputs: a,
+      inputs: o,
+      timeMs: l.then((e) => e.kernelMs),
+      extraInfo: l.then((e) => e.getExtraProfileInfo != null ? e.getExtraProfileInfo() : "")
+    };
+  }
+  logKernelProfile(s) {
+    const { kernelName: o, outputs: c, timeMs: a, inputs: r, extraInfo: l } = s;
+    c.forEach((p) => {
+      Promise.all([p.data(), a, l]).then((n) => {
+        this.logger.logKernelProfile(o, p, n[0], n[1], r, n[2]);
+      });
+    });
+  }
+}
+function L(t, s, o) {
+  if (s !== "float32")
+    return !1;
+  for (let c = 0; c < t.length; c++) {
+    const a = t[c];
+    if (isNaN(a) || !isFinite(a))
+      return console.warn(`Found ${a} in the result of '${o}'`), !0;
+  }
+  return !1;
+}
+class $ {
+  logKernelProfile(s, o, c, a, r, l) {
+    const p = typeof a == "number" ? D(`${a}ms`, 9) : a.error, n = D(s, 25), e = o.rank, i = o.size, u = D(o.shape.toString(), 14);
+    let f = "";
+    for (const h in r) {
+      const m = r[h];
+      if (m != null) {
+        const b = m.shape || o.shape, P = b.length;
+        f += `${h}: ${P}D ${P > 0 ? b : ""} `;
+      }
+    }
+    console.log(`%c${n}	%c${p}	%c${e}D ${u}	%c${i}	%c${f}	%c${l}`, "font-weight:bold", "color:red", "color:blue", "color: orange", "color: green", "color: steelblue");
+  }
+}
+function pe(t, s, o) {
+  const c = {}, a = {};
+  for (let n = 0; n < s.length; n++)
+    c[s[n].id] = !0;
+  for (let n = 0; n < t.length; n++) {
+    const e = t[n], i = e.inputs;
+    for (const u in i) {
+      const f = i[u];
+      let h = !1;
+      for (let m = 0; m < s.length; m++)
+        if (c[f.id]) {
+          e.outputs.forEach((b) => c[b.id] = !0), h = !0, a[e.id] = !0;
+          break;
+        }
+      if (h)
+        break;
+    }
+  }
+  const r = {};
+  r[o.id] = !0;
+  const l = {};
+  for (let n = t.length - 1; n >= 0; n--) {
+    const e = t[n], i = e.inputs;
+    for (let u = 0; u < e.outputs.length; u++)
+      if (r[e.outputs[u].id]) {
+        for (const f in i)
+          r[i[f].id] = !0, l[e.id] = !0;
+        break;
+      }
+  }
+  const p = [];
+  for (let n = 0; n < t.length; n++) {
+    const e = t[n];
+    if (a[e.id] && l[e.id]) {
+      const i = {};
+      for (const f in e.inputs) {
+        const h = e.inputs[f];
+        c[h.id] && (i[f] = h);
+      }
+      const u = Object.assign({}, e);
+      u.inputs = i, u.outputs = e.outputs, p.push(u);
+    }
+  }
+  return p;
+}
+function de(t, s, o, c) {
+  for (let a = s.length - 1; a >= 0; a--) {
+    const r = s[a], l = [];
+    if (r.outputs.forEach((n) => {
+      const e = t[n.id];
+      e != null ? l.push(e) : l.push(null);
+    }), r.gradient == null)
+      throw new Error(`Cannot compute gradient: gradient function not found for ${r.kernelName}.`);
+    const p = r.gradient(l);
+    for (const n in r.inputs) {
+      if (!(n in p))
+        throw new Error(`Cannot backprop through input ${n}. Available gradients found: ${Object.keys(p)}.`);
+      const e = o(() => p[n]());
+      if (e.dtype !== "float32")
+        throw new Error(`Error in gradient for op ${r.kernelName}. The gradient of input ${n} must have 'float32' dtype, but has '${e.dtype}'`);
+      const i = r.inputs[n];
+      if (!M(e.shape, i.shape))
+        throw new Error(`Error in gradient for op ${r.kernelName}. The gradient of input '${n}' has shape '${e.shape}', which does not match the shape of the input '${i.shape}'`);
+      if (t[i.id] == null)
+        t[i.id] = e;
+      else {
+        const u = t[i.id];
+        t[i.id] = c(u, e), u.dispose();
+      }
+    }
+  }
+}
+var C;
+(function(t) {
+  t.R0 = "R0", t.R1 = "R1", t.R2 = "R2", t.R3 = "R3", t.R4 = "R4", t.R5 = "R5", t.R6 = "R6";
+})(C || (C = {}));
+var T;
+(function(t) {
+  t.float32 = "float32", t.int32 = "int32", t.bool = "int32", t.complex64 = "complex64";
+})(T || (T = {}));
+var k;
+(function(t) {
+  t.float32 = "float32", t.int32 = "int32", t.bool = "bool", t.complex64 = "complex64";
+})(k || (k = {}));
+var N;
+(function(t) {
+  t.float32 = "float32", t.int32 = "float32", t.bool = "float32", t.complex64 = "complex64";
+})(N || (N = {}));
+var x;
+(function(t) {
+  t.float32 = "complex64", t.int32 = "complex64", t.bool = "complex64", t.complex64 = "complex64";
+})(x || (x = {}));
+const O = {
+  float32: N,
+  int32: T,
+  bool: k,
+  complex64: x
+};
+function B(t, s) {
+  if (t === "string" || s === "string") {
+    if (t === "string" && s === "string")
+      return "string";
+    throw new Error(`Can not upcast ${t} with ${s}`);
+  }
+  return O[t][s];
+}
+function fe(t) {
+  return B(t, "int32");
+}
+function he(t) {
+  return t != null && typeof t == "object" && "texture" in t && t.texture instanceof WebGLTexture;
+}
+function ge(t) {
+  return typeof GPUBuffer < "u" && t != null && typeof t == "object" && "buffer" in t && t.buffer instanceof GPUBuffer;
+}
+function me(t, s) {
+  if (t.dtype === s.dtype)
+    return [t, s];
+  const o = B(t.dtype, s.dtype);
+  return [t.cast(o), s.cast(o)];
+}
+function be(t, s) {
+  return s.some((o) => o.id === t.id);
+}
+function Se(t) {
+  const s = [];
+  return E(t, s, /* @__PURE__ */ new Set()), s;
+}
+function E(t, s, o) {
+  if (t == null)
+    return;
+  if (t instanceof w) {
+    s.push(t);
+    return;
+  }
+  if (!q(t))
+    return;
+  const c = t;
+  for (const a in c) {
+    const r = c[a];
+    o.has(r) || (o.add(r), E(r, s, o));
+  }
+}
+function q(t) {
+  return Array.isArray(t) || typeof t == "object";
+}
+export {
+  Vt as $,
+  j as A,
+  it as B,
+  Dt as C,
+  is as D,
+  Ht as E,
+  to as F,
+  os as G,
+  jo as H,
+  rs as I,
+  z as J,
+  K,
+  ms as L,
+  As as M,
+  $s as N,
+  be as O,
+  Us as P,
+  Qt as Q,
+  Qs as R,
+  Fo as S,
+  _o as T,
+  ko as U,
+  Kt as V,
+  ds as W,
+  Hs as X,
+  io as Y,
+  Jo as Z,
+  fe as _,
+  le as a,
+  Bt as a$,
+  ne as a0,
+  mt as a1,
+  se as a2,
+  de as a3,
+  he as a4,
+  ge as a5,
+  ts as a6,
+  Ls as a7,
+  St as a8,
+  _ as a9,
+  zs as aA,
+  Vs as aB,
+  ro as aC,
+  no as aD,
+  Wo as aE,
+  pt as aF,
+  gt as aG,
+  Wt as aH,
+  Xt as aI,
+  Xs as aJ,
+  po as aK,
+  Go as aL,
+  X as aM,
+  Y as aN,
+  Z as aO,
+  nt as aP,
+  rt as aQ,
+  Ko as aR,
+  lt as aS,
+  ss as aT,
+  Rt as aU,
+  kt as aV,
+  Nt as aW,
+  Pt as aX,
+  Ct as aY,
+  Ft as aZ,
+  yt as a_,
+  Zt as aa,
+  Zo as ab,
+  js as ac,
+  xo as ad,
+  Vo as ae,
+  Ps as af,
+  ut as ag,
+  mo as ah,
+  zt as ai,
+  Es as aj,
+  ns as ak,
+  as as al,
+  fs as am,
+  hs as an,
+  bs as ao,
+  Ss as ap,
+  Bs as aq,
+  Ms as ar,
+  Os as as,
+  uo as at,
+  wo as au,
+  Xo as av,
+  It as aw,
+  Jt as ax,
+  te as ay,
+  qs as az,
+  eo as b,
+  Mo as b$,
+  Mt as b0,
+  Ut as b1,
+  No as b2,
+  Ds as b3,
+  vs as b4,
+  Fs as b5,
+  _s as b6,
+  Ks as b7,
+  Ws as b8,
+  vo as b9,
+  us as bA,
+  ps as bB,
+  Ts as bC,
+  Ns as bD,
+  ks as bE,
+  ys as bF,
+  Cs as bG,
+  ws as bH,
+  co as bI,
+  ao as bJ,
+  To as bK,
+  Ao as bL,
+  zo as bM,
+  ft as bN,
+  Et as bO,
+  Gt as bP,
+  qt as bQ,
+  Yt as bR,
+  Qo as bS,
+  ee as bT,
+  cs as bU,
+  gs as bV,
+  Rs as bW,
+  Is as bX,
+  go as bY,
+  Bo as bZ,
+  Eo as b_,
+  lo as ba,
+  bo as bb,
+  Ro as bc,
+  Yo as bd,
+  Tt as be,
+  oe as bf,
+  wt as bg,
+  At as bh,
+  U as bi,
+  W as bj,
+  H as bk,
+  J as bl,
+  Q as bm,
+  tt as bn,
+  et as bo,
+  st as bp,
+  ot as bq,
+  ct as br,
+  at as bs,
+  dt as bt,
+  xt as bu,
+  Lt as bv,
+  Ot as bw,
+  $t as bx,
+  _t as by,
+  ls as bz,
+  Co as c,
+  Lo as c0,
+  $o as c1,
+  ho as c2,
+  Uo as c3,
+  Ho as c4,
+  Ys as c5,
+  Zs as c6,
+  Js as c7,
+  yo as c8,
+  Io as c9,
+  Oo as ca,
+  qo as cb,
+  so as d,
+  oo as e,
+  So as f,
+  Po as g,
+  bt as h,
+  Gs as i,
+  fo as j,
+  es as k,
+  vt as l,
+  me as m,
+  Do as n,
+  ue as o,
+  ce as p,
+  ae as q,
+  ie as r,
+  re as s,
+  Se as t,
+  B as u,
+  pe as v,
+  y as w,
+  ht as x,
+  xs as y,
+  jt as z
+};