@genai-fi/nanogpt 0.10.2 → 0.11.0

package/dist/dropout-OxuaJz6z.js

@@ -0,0 +1,92 @@
+import { q as l, w as h, at as d, ac as f, u as m, y as u, a4 as p, l as g, n as V, m as v } from "./index-D0RBWjq8.js";
+import { f as w } from "./floor-DIb-lN_u.js";
+import { s as c } from "./index-CieiGp4Y.js";
+class N {
+  constructor(t, e, s, n, o) {
+    this.mean = t, this.stdDev = e, 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 a = o || Math.random();
+    this.random = c.alea(a.toString());
+  }
+  /** Returns next sample from a Gaussian distribution. */
+  nextValue() {
+    if (!isNaN(this.nextVal)) {
+      const n = this.nextVal;
+      return this.nextVal = NaN, n;
+    }
+    let t, e, s = !1;
+    for (; !s; ) {
+      let n, o, a;
+      do
+        n = 2 * this.random() - 1, o = 2 * this.random() - 1, a = n * n + o * o;
+      while (a >= 1 || a === 0);
+      const i = Math.sqrt(-2 * Math.log(a) / a);
+      t = this.mean + this.stdDev * n * i, e = this.mean + this.stdDev * o * i, (!this.truncated || this.isValidTruncated(t)) && (s = !0);
+    }
+    return (!this.truncated || this.isValidTruncated(e)) && (this.nextVal = this.convertValue(e)), 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 b {
+  constructor(t = 0, e = 1, s, n) {
+    if (this.canReturnFloat = () => this.dtype == null || this.dtype === "float32", this.min = t, this.range = e - 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} - ${e} <= 1 and dtype is not float`);
+    this.random = c.alea(n);
+  }
+  convertValue(t) {
+    return this.canReturnFloat() ? t : Math.round(t);
+  }
+  nextValue() {
+    return this.convertValue(this.min + this.range * this.random());
+  }
+}
+function y(r, t = 0, e = 1, s, n) {
+  if (h(r), s != null && s === "bool")
+    throw new Error(`Unsupported data type ${s}`);
+  const o = new N(t, e, s, !1, n), a = d(r, s);
+  for (let i = 0; i < a.values.length; i++)
+    a.values[i] = o.nextValue();
+  return a.toTensor();
+}
+const U = /* @__PURE__ */ l({ randomNormal_: y });
+function T(r, t = 0, e = 1, s = "float32", n) {
+  h(r);
+  const o = d(r, s), a = new b(t, e, null, n);
+  for (let i = 0; i < o.values.length; i++)
+    o.values[i] = a.nextValue();
+  return o.toTensor();
+}
+const M = /* @__PURE__ */ l({ randomUniform_: T });
+function x(r, t) {
+  if (t == null)
+    return r.shape.slice();
+  if (f(r.shape, t))
+    return t;
+  if (r.shape.length === t.length) {
+    const e = [];
+    for (let s = 0; s < r.shape.length; s++)
+      t[s] == null && r.shape[s] != null ? e.push(r.shape[s]) : e.push(t[s]);
+    return e;
+  }
+  return t;
+}
+function D(r, t, e, s) {
+  const n = m(r, "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 r instanceof p ? n.clone() : n;
+  const o = x(n, e), a = 1 - t, i = g(w(V(M(o, 0, 1, "float32", s), a)), a);
+  return v(n, i);
+}
+const q = /* @__PURE__ */ l({ dropout_: D });
+export {
+  N as M,
+  M as a,
+  q as d,
+  U as r
+};

package/dist/expand_dims-BzfJK2uc.js

@@ -0,0 +1,11 @@
+import { q as o, u as a, y as i, E as m, B as p } from "./index-D0RBWjq8.js";
+function u(t, n = 0) {
+  const s = a(t, "x", "expandDims", "string_or_numeric");
+  i(n <= s.rank, () => "Axis must be <= rank of the tensor");
+  const r = { input: s }, e = { dim: n };
+  return m.runKernel(p, r, e);
+}
+const x = /* @__PURE__ */ o({ expandDims_: u });
+export {
+  x as e
+};

package/dist/{exports_initializers-CZSUJoVE.js → exports_initializers-eS9QJ6ut.js}

@@ -1,4 +1,4 @@
-import { R as o } from "./random_width-BVV9HveY.js";
+import { R as o } from "./random_width-UGQn4OWb.js";
 function m(r) {
   return new o(r);
 }

package/dist/floor-DIb-lN_u.js

@@ -0,0 +1,9 @@
+import { q as n, u as s, E as t, F as f } from "./index-D0RBWjq8.js";
+function a(o) {
+  const r = { x: s(o, "x", "floor", "float32") };
+  return t.runKernel(f, r);
+}
+const c = /* @__PURE__ */ n({ floor_: a });
+export {
+  c as f
+};

package/dist/gather-BcO5UQNJ.js

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

package/dist/{gelu-Bmhopi0J.js → gelu-DqTbCx5x.js}

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