@genai-fi/nanogpt 0.9.0 → 0.10.0

package/dist/dropout-C1pM3f11.js

@@ -0,0 +1,99 @@
+import { d as h, b as m, a as u, T as p } from "./tensor-DdQUJZlz.js";
+import { A as l, B as c, E as g, J as f, l as V, n as v, m as N } from "./index-ZyQhjEPo.js";
+import { Q as w } from "./tensor_util-DV-FP5Q3.js";
+import { s as d } from "./index-CieiGp4Y.js";
+function b(e) {
+  const r = { x: c(e, "x", "floor", "float32") };
+  return g.runKernel(w, r);
+}
+const x = /* @__PURE__ */ l({ floor_: b });
+class T {
+  constructor(t, r, s, n, a) {
+    this.mean = t, this.stdDev = r, this.dtype = s, this.nextVal = NaN, this.truncated = n, this.truncated && (this.upper = this.mean + this.stdDev * 2, this.lower = this.mean - this.stdDev * 2);
+    const o = a || Math.random();
+    this.random = d.alea(o.toString());
+  }
+  /** Returns next sample from a Gaussian distribution. */
+  nextValue() {
+    if (!isNaN(this.nextVal)) {
+      const n = this.nextVal;
+      return this.nextVal = NaN, n;
+    }
+    let t, r, s = !1;
+    for (; !s; ) {
+      let n, a, o;
+      do
+        n = 2 * this.random() - 1, a = 2 * this.random() - 1, o = n * n + a * a;
+      while (o >= 1 || o === 0);
+      const i = Math.sqrt(-2 * Math.log(o) / o);
+      t = this.mean + this.stdDev * n * i, r = this.mean + this.stdDev * a * i, (!this.truncated || this.isValidTruncated(t)) && (s = !0);
+    }
+    return (!this.truncated || this.isValidTruncated(r)) && (this.nextVal = this.convertValue(r)), this.convertValue(t);
+  }
+  /** Handles proper rounding for non-floating-point numbers. */
+  convertValue(t) {
+    return this.dtype == null || this.dtype === "float32" ? t : Math.round(t);
+  }
+  /** Returns true if less than 2-standard-deviations from the mean. */
+  isValidTruncated(t) {
+    return t <= this.upper && t >= this.lower;
+  }
+}
+class $ {
+  constructor(t = 0, r = 1, s, n) {
+    if (this.canReturnFloat = () => this.dtype == null || this.dtype === "float32", this.min = t, this.range = r - t, this.dtype = s, n == null && (n = Math.random()), typeof n == "number" && (n = n.toString()), !this.canReturnFloat() && this.range <= 1)
+      throw new Error(`The difference between ${t} - ${r} <= 1 and dtype is not float`);
+    this.random = d.alea(n);
+  }
+  convertValue(t) {
+    return this.canReturnFloat() ? t : Math.round(t);
+  }
+  nextValue() {
+    return this.convertValue(this.min + this.range * this.random());
+  }
+}
+function y(e, t = 0, r = 1, s, n) {
+  if (h(e), s != null && s === "bool")
+    throw new Error(`Unsupported data type ${s}`);
+  const a = new T(t, r, s, !1, n), o = f(e, s);
+  for (let i = 0; i < o.values.length; i++)
+    o.values[i] = a.nextValue();
+  return o.toTensor();
+}
+const q = /* @__PURE__ */ l({ randomNormal_: y });
+function M(e, t = 0, r = 1, s = "float32", n) {
+  h(e);
+  const a = f(e, s), o = new $(t, r, null, n);
+  for (let i = 0; i < a.values.length; i++)
+    a.values[i] = o.nextValue();
+  return a.toTensor();
+}
+const D = /* @__PURE__ */ l({ randomUniform_: M });
+function E(e, t) {
+  if (t == null)
+    return e.shape.slice();
+  if (m(e.shape, t))
+    return t;
+  if (e.shape.length === t.length) {
+    const r = [];
+    for (let s = 0; s < e.shape.length; s++)
+      t[s] == null && e.shape[s] != null ? r.push(e.shape[s]) : r.push(t[s]);
+    return r;
+  }
+  return t;
+}
+function R(e, t, r, s) {
+  const n = c(e, "x", "dropout");
+  if (u(n.dtype === "float32", () => `x has to be a floating point tensor since it's going to be scaled, but got a ${n.dtype} tensor instead.`), u(t >= 0 && t < 1, () => `rate must be a float in the range [0, 1), but got ${t}.`), t === 0)
+    return e instanceof p ? n.clone() : n;
+  const a = E(n, r), o = 1 - t, i = V(x(v(D(a, 0, 1, "float32", s), o)), o);
+  return N(n, i);
+}
+const I = /* @__PURE__ */ l({ dropout_: R });
+export {
+  T as M,
+  D as a,
+  I as d,
+  x as f,
+  q as r
+};

package/dist/expand_dims-BPG4fwBP.js

@@ -0,0 +1,13 @@
+import { A as e, B as a, E as i } from "./index-ZyQhjEPo.js";
+import { E as m } from "./tensor_util-DV-FP5Q3.js";
+import { a as p } from "./tensor-DdQUJZlz.js";
+function c(r, n = 0) {
+  const s = a(r, "x", "expandDims", "string_or_numeric");
+  p(n <= s.rank, () => "Axis must be <= rank of the tensor");
+  const t = { input: s }, o = { dim: n };
+  return i.runKernel(m, t, o);
+}
+const f = /* @__PURE__ */ e({ expandDims_: c });
+export {
+  f as e
+};

package/dist/exports_initializers-xuidcwI4.js

@@ -0,0 +1,7 @@
+import { R as o } from "./random_width-DY6Kk2Dl.js";
+function m(r) {
+  return new o(r);
+}
+export {
+  m as r
+};

package/dist/gather-DykLGqmW.js

@@ -0,0 +1,10 @@
+import { A as g, B as t, E as h } from "./index-ZyQhjEPo.js";
+import { G as p } from "./tensor_util-DV-FP5Q3.js";
+function m(n, r, s = 0, o = 0) {
+  const e = t(n, "x", "gather"), a = t(r, "indices", "gather", "int32"), i = { x: e, indices: a }, c = { axis: s, batchDims: o };
+  return h.runKernel(p, i, c);
+}
+const d = /* @__PURE__ */ g({ gather_: m });
+export {
+  d as g
+};

package/dist/{gelu-Bp_-935b.js → gelu-CNLFZWea.js}

@@ -1,26 +1,27 @@
-import { i as t, e as n } from "./index-BzFyqcy-.js";
+import { e as n } from "./index-ZyQhjEPo.js";
 import "./ops/cpu/gelu.js";
 import "./ops/webgl/gelu.js";
-const a = {
+import { a as u } from "./tensor_util-DV-FP5Q3.js";
+const o = {
   kernelName: "Gelu",
   inputsToSave: ["x"],
   outputsToSave: [],
   gradFunc: (e, r) => {
-    const [u] = r;
+    const [t] = r;
     return {
-      x: () => o(e, u)
+      x: () => a(e, t)
     };
   }
 };
-t(a);
-function g(e) {
+u(o);
+function m(e) {
   return n().runKernel("Gelu", { x: e });
 }
-function o(e, r) {
+function a(e, r) {
   return n().runKernel("GeluGrad", { dy: e, x: r });
 }
 export {
-  a,
-  o as d,
-  g
+  o as a,
+  a as d,
+  m as g
 };