@genai-fi/nanogpt 0.4.5 → 0.5.0

package/dist/{TiedEmbedding-DznFwzcB.js → TiedEmbedding-DsDRvLB0.js}

@@ -1,26 +1,27 @@
-import { o as F, h as D, E as M, bb as fo, bc as mo, bd as mi, j as k, b9 as Mn, be as gi, x as L, bf as bi, bg as yi, bh as wi, bi as ki, bj as xi, bk as vi, bl as Ni, bm as go, bn as Si, bo, bp as Ai, bq as yo, br as Ci, p as Hn, O as wt, bs as wo, bt as Ii, bu as Di, bv as zi, c as On, s as V, b as w, bw as ko, bx as Ti, by as $i, bz as xo, bA as Ei, bB as Li, bC as Fi, bD as Mi, bE as Oi, bF as Ri, bG as _i, bH as Bi, k as vo, ag as No, bI as Wi, bJ as So, a8 as $, bK as Ls, bL as Ao, bM as Co, bN as Io, bO as Do, bP as zo, A as To, bQ as $o, bR as Eo, bS as Lo, bT as S, t as x, f as tt, n as Gi, bU as Be, bV as We, ad as Ft, a as Z, L as Fo, bW as Mo, bX as Oo, a0 as ct, a3 as ee, ai as P, bY as Ro, bZ as _o, aP as lt, b_ as Bo, z as Q, b$ as Wo, c0 as Go, c1 as Po, c2 as Uo, c3 as Vo, c4 as jo, c5 as Ko, c6 as Ho, B as qo, c7 as Zo, c8 as Jo, c9 as Xo, as as Yo, ca as Qo, C as tl, $ as he, cb as el, V as nl, cc as sl, cd as il, ce as rl, av as al, cf as ol, a6 as ll, aw as ul, cg as cl, af as hl, ch as pl, G as dl, ay as fl, ci as ml, cj as gl, ck as bl, cl as yl, aA as wl, a7 as kl, cm as xl, cn as vl, co as Nl, M as Sl, cp as Al, cq as Cl, cr as Il, _ as Dl, a1 as zl, aF as Tl, cs as $l, a9 as El, ct as Ll, aD as Fl, P as Ml, cu as Ol, U as qn, aG as Rl, cv as _l, cw as Bl, T as Wl, aJ as Gl, aI as Pl, q as Ul, aX as Vl, cx as jl, aY as Kl, cy as Hl, aK as ql, at as Zl, ap as Jl, cz as Xl, W as Yl, aq as Ql, S as tu, u as eu, cA as nu, cB as su, cC as iu, aM as ru, cD as au, y as ou, cE as lu, a4 as uu, aO as cu, aN as hu, cF as Ie, cG as pu, g as du, cH as Fs, F as Bt, a2 as Fe, D as fu, w as mu, ah as xe, cI as gu, cJ as bu, m as Ms, cK as yu, cL as Os, cM as wu } from "./index--6vO-cOz.js";
-import { s as ku, a as xu, g as vu, b as Nu, V as d, N as G, r as bn, e as Su, l as Au, c as Zn, f as et, h as ye, i as Ge, j as Jn, k as Pi, m as Ui, t as Rt, R as Et, n as ht, A as Pt, o as K, p as le, q as Xn, u as pt, w as Ht, v as Pe, x as Ue, y as Yn, z as j, B as Ee, C as Gt, D as Cu, E as be, F as en, G as Qn, H as ue, I as Ct, J as nt, K as Ve, L as Iu, M as Du, O as je, P as Ut, Q as Lt, S as ts, T as oe, U as jt, W as Xe, X as ce, Y as zu, Z as Rn, _ as nn, $ as yn, a0 as Vi, a1 as It, a2 as Rs, a3 as Tu, a4 as ji, a5 as $u, a6 as Eu, a7 as Lu, a8 as Fu, a9 as Mu, aa as qt, ab as Ou, ac as es, ad as zt, ae as Ye, af as Ru, ag as _t, ah as ot, ai as Ki, aj as gt, ak as ne, al as _s, am as ve, d as St, an as Bs, ao as Ke, ap as Hi, aq as ns, ar as _u, as as Bu, at as qi, au as Wu } from "./tfjs_backend-DuKis_xG.js";
-import { M as Gu, a as wn, f as Zi } from "./dropout-DFEXTPV0.js";
-import { z as mt } from "./zeros-8xl-W2DC.js";
-import { o as pe } from "./ones-D6kB8bdY.js";
-import { v as Ji } from "./variable-BJTZ3jOy.js";
-import { r as A } from "./reshape-z51Eu-re.js";
-import { s as B } from "./sum-DdkDf2MG.js";
-import { m as Ot } from "./mat_mul-BEHRPMh0.js";
-import { s as Kt } from "./split-B_k_jwud.js";
-import { s as Pu, c as Xi } from "./sin-H567uayl.js";
-import { g as Yi, d as ss, e as Ws, c as Uu } from "./axis_util-QP0LdI1v.js";
-import { a as Zt, e as Jt, l as Vu } from "./log_sum_exp-CiEy1aUe.js";
-import { s as kn } from "./stack-CmqSdsfs.js";
-import { p as ju } from "./slice_util-BdhYwFY_.js";
-import { c as is } from "./concat-DvWM7HGZ.js";
-import { g as Qi } from "./gather-C5D8PxwA.js";
-import { m as at, a as rs } from "./moments-DYOHXoRV.js";
-import { s as tr } from "./softmax-Dsxflvdl.js";
-import { m as Ne } from "./max-BUShNgfh.js";
-import { t as Ku } from "./tensor-BGYi41cj.js";
-import { r as Hu } from "./range-C_vpUjBu.js";
-import { m as qu } from "./norm-DSva3hI3.js";
+import { o as F, i as D, E as M, bb as fo, bc as mo, bd as mi, k, b9 as Mn, be as gi, y as L, bf as bi, bg as yi, bh as wi, bi as ki, bj as xi, bk as Ni, bl as vi, bm as go, bn as Si, bo, bp as Ai, bq as yo, br as Ci, q as Hn, N as wt, bs as wo, bt as Ii, bu as Di, bv as zi, c as On, s as V, b as w, bw as ko, bx as Ti, by as $i, bz as xo, bA as Ei, bB as Li, bC as Fi, bD as Mi, bE as Oi, bF as Ri, bG as _i, bH as Bi, l as No, ah as vo, bI as Wi, bJ as So, a9 as $, bK as Ls, bL as Ao, bM as Co, bN as Io, bO as Do, bP as zo, A as To, bQ as $o, bR as Eo, bS as Lo, bT as S, t as x, f as tt, p as Gi, bU as Be, bV as We, ae as Ft, a as Z, K as Fo, bW as Mo, bX as Oo, a2 as ct, a5 as ee, ai as P, bY as Ro, bZ as _o, ax as lt, b_ as Bo, z as Q, b$ as Wo, c0 as Go, c1 as Po, c2 as Uo, c3 as Vo, c4 as jo, c5 as Ko, c6 as Ho, B as qo, c7 as Zo, c8 as Jo, c9 as Xo, aq as Yo, ca as Qo, C as tl, a1 as he, cb as el, _ as nl, cc as sl, cd as il, ce as rl, ar as al, cf as ol, a7 as ll, aE as ul, cg as cl, ag as hl, ch as pl, G as dl, aG as fl, ci as ml, cj as gl, ck as bl, cl as yl, as as wl, a8 as kl, cm as xl, cn as Nl, co as vl, M as Sl, cp as Al, cq as Cl, cr as Il, a0 as Dl, a3 as zl, aM as Tl, cs as $l, aa as El, ct as Ll, aK as Fl, P as Ml, cu as Ol, U as qn, at as Rl, cv as _l, cw as Bl, Q as Wl, av as Gl, au as Pl, u as Ul, aY as Vl, cx as jl, aZ as Kl, cy as Hl, aO as ql, aC as Zl, ap as Jl, cz as Xl, $ as Yl, aA as Ql, S as tu, w as eu, cA as nu, cB as su, cC as iu, aw as ru, cD as au, D as ou, cE as lu, T as uu, aR as cu, aQ as hu, cF as Ie, cG as pu, h as du, cH as Fs, F as Bt, a4 as Fe, g as fu, x as mu, V as xe, cI as gu, cJ as bu, m as Ms, cK as yu, cL as Os, cM as wu } from "./index-iNhkcAEQ.js";
+import { s as ku, a as xu, g as Nu, b as vu, V as d, N as G, r as bn, c as Zn, e as et, f as ye, h as Ge, i as Jn, j as Pi, k as Ui, t as Rt, R as Et, l as ht, A as Pt, m as K, n as le, o as Xn, p as Yn, q as Ct, u as nt, v as Pe, w as Su, x as Au, y as Ue, z as Ut, B as Lt, C as oe, D as jt, E as Xe, F as ue, G as Cu, H as en, I as yn, J as Vi, K as It, L as Rs, M as Iu, O as Du, P as zu, Q as Tu, S as $u, T as Eu, U as Ht, W as Lu, X as Qn, Y as zt, Z as Ye, _ as Fu, $ as ot, a0 as ji, a1 as gt, a2 as ne, a3 as _s, a4 as Ne, d as St, a5 as Bs, a6 as Ve, a7 as Ki, a8 as ts, a9 as Mu, aa as Ou, ab as Hi, ac as Ru } from "./tfjs_backend-NucKez4s.js";
+import { M as _u, a as wn, f as qi } from "./dropout-kbDY39Ci.js";
+import { e as Bu, l as Wu, n as pt, w as qt, c as je, g as Ke, d as es, b as j, a as Ee, f as Gt, h as Gu, s as be, u as nn, i as ce, j as ns, t as Rn, m as Zi, k as _t } from "./ops-ObfXLHYQ.js";
+import { z as mt } from "./zeros-NMYTayy7.js";
+import { o as pe } from "./ones-BIeFnPHR.js";
+import { v as Ji, B as Pu } from "./BaseLayer-BhrMN8JO.js";
+import { r as A } from "./reshape-DxTPgnwL.js";
+import { s as B } from "./sum-B_92TaHD.js";
+import { m as Ot } from "./mat_mul-D0SifYfJ.js";
+import { s as Kt } from "./split-BCbrzthj.js";
+import { s as Uu, c as Xi } from "./sin-BOX-JVAj.js";
+import { g as Yi, d as ss, e as Ws, c as Vu } from "./axis_util-97KkkyRQ.js";
+import { a as Zt, e as Jt, l as ju } from "./log_sum_exp-CkumwesB.js";
+import { s as kn } from "./stack--cqr9Dgc.js";
+import { p as Ku } from "./slice_util-D-kaD4ZV.js";
+import { c as is } from "./concat-Cxbo2sOz.js";
+import { g as Qi } from "./gather-Bxe1Qip8.js";
+import { m as at, a as rs } from "./moments-B06NlR_V.js";
+import { s as tr } from "./softmax-BjsptB07.js";
+import { m as ve } from "./max-CYaAjEEp.js";
+import { t as Hu } from "./tensor-CfiPXsW4.js";
+import { r as qu } from "./range-BsFU-SNG.js";
+import { m as Zu } from "./norm-D3676xIo.js";
 /**
  * @license
  * Copyright 2020 Google LLC. All Rights Reserved.
@@ -37,11 +38,11 @@ import { m as qu } from "./norm-DSva3hI3.js";
  * limitations under the License.
  * =============================================================================
  */
-function Zu(s, t = null, e = !1) {
+function Ju(s, t = null, e = !1) {
   const i = { x: D(s, "x", "all", "bool") }, r = { axis: t, keepDims: e };
   return M.runKernel(fo, i, r);
 }
-const Ju = /* @__PURE__ */ F({ all_: Zu });
+const Xu = /* @__PURE__ */ F({ all_: Ju });
 /**
  * @license
  * Copyright 2020 Google LLC. All Rights Reserved.
@@ -58,11 +59,11 @@ const Ju = /* @__PURE__ */ F({ all_: Zu });
  * limitations under the License.
  * =============================================================================
  */
-function Xu(s, t = null, e = !1) {
+function Yu(s, t = null, e = !1) {
   const i = { x: D(s, "x", "any", "bool") }, r = { axis: t, keepDims: e };
   return M.runKernel(mo, i, r);
 }
-const Gs = /* @__PURE__ */ F({ any_: Xu });
+const Gs = /* @__PURE__ */ F({ any_: Yu });
 /**
  * @license
  * Copyright 2020 Google Inc. All Rights Reserved.
@@ -79,11 +80,11 @@ const Gs = /* @__PURE__ */ F({ any_: Xu });
  * limitations under the License.
  * =============================================================================
  */
-function Yu(s, t = 0) {
+function Qu(s, t = 0) {
   const n = { x: D(s, "x", "argMax") }, i = { axis: t };
   return M.runKernel(mi, n, i);
 }
-const sn = /* @__PURE__ */ F({ argMax_: Yu });
+const sn = /* @__PURE__ */ F({ argMax_: Qu });
 /**
  * @license
  * Copyright 2020 Google LLC. All Rights Reserved.
@@ -100,7 +101,7 @@ const sn = /* @__PURE__ */ F({ argMax_: Yu });
  * limitations under the License.
  * =============================================================================
  */
-function Qu(s, t, e, n, i, r, a = !1, o = "channelsLast") {
+function tc(s, t, e, n, i, r, a = !1, o = "channelsLast") {
   let [l, u, c, h] = [-1, -1, -1, -1];
   if (o === "channelsLast")
     [l, u, c, h] = s;
@@ -108,7 +109,7 @@ function Qu(s, t, e, n, i, r, a = !1, o = "channelsLast") {
     [l, h, u, c] = s;
   else
     throw new Error(`Unknown dataFormat ${o}`);
-  const [p, f, , g] = t, [b, m] = rn(e), [N, y] = rn(n), C = _n(p, N), v = _n(f, y), { padInfo: I, outHeight: z, outWidth: _ } = nc(i, u, c, b, m, C, v, r, o), T = a ? g * h : g;
+  const [p, f, , g] = t, [b, m] = rn(e), [v, y] = rn(n), C = _n(p, v), N = _n(f, y), { padInfo: I, outHeight: z, outWidth: _ } = sc(i, u, c, b, m, C, N, r, o), T = a ? g * h : g;
   let E;
   return o === "channelsFirst" ? E = [l, T, z, _] : o === "channelsLast" && (E = [l, z, _, T]), {
     batchSize: l,
@@ -125,20 +126,20 @@ function Qu(s, t, e, n, i, r, a = !1, o = "channelsLast") {
     filterHeight: p,
     filterWidth: f,
     effectiveFilterHeight: C,
-    effectiveFilterWidth: v,
-    dilationHeight: N,
+    effectiveFilterWidth: N,
+    dilationHeight: v,
     dilationWidth: y,
     inShape: s,
     outShape: E,
     filterShape: t
   };
 }
-function tc(s, t, e, n, i) {
-  n == null && (n = ec(s, t, e));
+function ec(s, t, e, n, i) {
+  n == null && (n = nc(s, t, e));
   const r = s[0], a = s[1], o = an((r - t + 2 * n) / e + 1, i), l = an((a - t + 2 * n) / e + 1, i);
   return [o, l];
 }
-function ec(s, t, e, n = 1) {
+function nc(s, t, e, n = 1) {
   const i = _n(t, n);
   return Math.floor((s[0] * (e - 1) - e + i) / 2);
 }
@@ -148,16 +149,16 @@ function rn(s) {
 function _n(s, t) {
   return t <= 1 ? s : s + (s - 1) * (t - 1);
 }
-function nc(s, t, e, n, i, r, a, o, l) {
+function sc(s, t, e, n, i, r, a, o, l) {
   let u, c, h;
   if (typeof s == "number") {
     u = { top: s, bottom: s, left: s, right: s, type: s === 0 ? "VALID" : "NUMBER" };
-    const f = tc([t, e], r, n, s, o);
+    const f = ec([t, e], r, n, s, o);
     c = f[0], h = f[1];
   } else if (s === "same") {
     c = Math.ceil(t / n), h = Math.ceil(e / i);
-    const p = Math.max(0, (c - 1) * n + r - t), f = Math.max(0, (h - 1) * i + a - e), g = Math.floor(p / 2), b = p - g, m = Math.floor(f / 2), N = f - m;
-    u = { top: g, bottom: b, left: m, right: N, type: "SAME" };
+    const p = Math.max(0, (c - 1) * n + r - t), f = Math.max(0, (h - 1) * i + a - e), g = Math.floor(p / 2), b = p - g, m = Math.floor(f / 2), v = f - m;
+    u = { top: g, bottom: b, left: m, right: v, type: "SAME" };
   } else if (s === "valid")
     u = { top: 0, bottom: 0, left: 0, right: 0, type: "VALID" }, c = Math.ceil((t - r + 1) / n), h = Math.ceil((e - a + 1) / i);
   else if (typeof s == "object") {
@@ -223,7 +224,7 @@ function ft(s, t, e) {
  * limitations under the License.
  * =============================================================================
  */
-function sc(s, t, e, n, i) {
+function ic(s, t, e, n, i) {
   const r = D(s, "x", "avgPool", "float32"), a = 1;
   k(de(e, a), () => `Error in avgPool: Either strides or dilations must be 1. Got strides ${e} and dilations '${a}'`);
   let o = r, l = !1;
@@ -232,7 +233,7 @@ function sc(s, t, e, n, i) {
   let h = M.runKernel(gi, u, c);
   return h = L(h, r.dtype), l ? A(h, [h.shape[1], h.shape[2], h.shape[3]]) : h;
 }
-const ic = /* @__PURE__ */ F({ avgPool_: sc });
+const rc = /* @__PURE__ */ F({ avgPool_: ic });
 /**
  * @license
  * Copyright 2020 Google LLC. All Rights Reserved.
@@ -249,7 +250,7 @@ const ic = /* @__PURE__ */ F({ avgPool_: sc });
  * limitations under the License.
  * =============================================================================
  */
-function rc(s, t, e, n, i, r = "NDHWC") {
+function ac(s, t, e, n, i, r = "NDHWC") {
   const a = D(s, "x", "avgPool3d", "float32");
   let o = a, l = !1;
   a.rank === 4 && (l = !0, o = A(a, [1, a.shape[0], a.shape[1], a.shape[2], a.shape[3]])), k(o.rank === 5, () => `Error in avgPool3d: x must be rank 5 but got rank ${o.rank}.`), k(r === "NDHWC", () => `Error in avgPool3d: Only NDHWC is currently supported, but got dataFormat of ${r}`), k(typeof e == "number" && e > 0 || Array.isArray(e) && e[0] > 0 && e[1] > 0 && e[2] > 0, () => `Error in avgPool3d: Stride must be > 0, but got '${e}'`), ft("avgPool3d", n, i);
@@ -257,7 +258,7 @@ function rc(s, t, e, n, i, r = "NDHWC") {
   let h = M.runKernel(bi, u, c);
   return h = L(h, o.dtype), l ? A(h, [h.shape[1], h.shape[2], h.shape[3], h.shape[4]]) : h;
 }
-const ac = /* @__PURE__ */ F({ avgPool3d_: rc });
+const oc = /* @__PURE__ */ F({ avgPool3d_: ac });
 /**
  * @license
  * Copyright 2018 Google LLC. All Rights Reserved.
@@ -274,11 +275,11 @@ const ac = /* @__PURE__ */ F({ avgPool3d_: rc });
  * limitations under the License.
  * =============================================================================
  */
-function oc(s) {
+function lc(s) {
   const e = { x: D(s, "x", "tanh", "float32") };
   return M.runKernel(yi, e);
 }
-const as = /* @__PURE__ */ F({ tanh_: oc });
+const as = /* @__PURE__ */ F({ tanh_: lc });
 /**
  * @license
  * Copyright 2020 Google LLC. All Rights Reserved.
@@ -295,14 +296,14 @@ const as = /* @__PURE__ */ F({ tanh_: oc });
  * limitations under the License.
  * =============================================================================
  */
-function lc(s, t, e) {
+function uc(s, t, e) {
   const n = D(s, "x", "batchToSpaceND"), i = t.reduce((o, l) => o * l);
   k(n.rank >= 1 + t.length, () => `input rank is ${n.rank} but should be > than blockShape.length ${t.length}`), k(e.length === t.length, () => `crops.length is ${e.length} but should be equal to blockShape.length  ${t.length}`), k(n.shape[0] % i === 0, () => `input tensor batch is ${n.shape[0]} but is not divisible by the product of the elements of blockShape ${t.join(" * ")} === ${i}`);
   const r = { x: n }, a = { blockShape: t, crops: e };
   return M.runKernel(wi, r, a);
 }
-const uc = /* @__PURE__ */ F({ batchToSpaceND_: lc });
-function cc(s) {
+const cc = /* @__PURE__ */ F({ batchToSpaceND_: uc });
+function hc(s) {
   let t;
   return s.rank === 0 || s.rank === 1 ? t = A(s, [1, 1, 1, s.size]) : s.rank === 2 ? t = A(s, [1, 1, s.shape[0], s.shape[1]]) : s.rank === 3 ? t = A(s, [1, s.shape[0], s.shape[1], s.shape[2]]) : t = s, t;
 }
@@ -322,7 +323,7 @@ function cc(s) {
  * limitations under the License.
  * =============================================================================
  */
-function hc(s, t, e, n, i, r) {
+function pc(s, t, e, n, i, r) {
   r == null && (r = 1e-3);
   const a = D(s, "x", "batchNorm"), o = D(t, "mean", "batchNorm"), l = D(e, "variance", "batchNorm");
   let u;
@@ -330,7 +331,7 @@ function hc(s, t, e, n, i, r) {
   let c;
   n != null && (c = D(n, "offset", "batchNorm")), k(o.rank === l.rank, () => "Batch normalization gradient requires mean and variance to have equal ranks."), k(c == null || o.rank === c.rank, () => "Batch normalization gradient requires mean and offset to have equal ranks."), k(u == null || o.rank === u.rank, () => "Batch normalization gradient requires mean and scale to have equal ranks.");
   const p = {
-    x: cc(a),
+    x: hc(a),
     scale: u,
     offset: c,
     mean: o,
@@ -338,31 +339,31 @@ function hc(s, t, e, n, i, r) {
   }, f = { varianceEpsilon: r }, g = M.runKernel(ki, p, f);
   return A(g, a.shape);
 }
-const os = /* @__PURE__ */ F({ batchNorm_: hc });
-function pc(s, t, e, n, i, r) {
+const os = /* @__PURE__ */ F({ batchNorm_: pc });
+function dc(s, t, e, n, i, r) {
   const a = D(s, "x", "batchNorm"), o = D(t, "mean", "batchNorm"), l = D(e, "variance", "batchNorm");
   let u;
   i != null && (u = D(i, "scale", "batchNorm"));
   let c;
   return n != null && (c = D(n, "offset", "batchNorm")), k(a.rank === 2, () => `Error in batchNorm2D: x must be rank 2 but got rank ${a.rank}.`), k(o.rank === 2 || o.rank === 1, () => `Error in batchNorm2D: mean must be rank 2 or rank 1 but got rank ${o.rank}.`), k(l.rank === 2 || l.rank === 1, () => `Error in batchNorm2D: variance must be rank 2 or rank 1 but got rank ${l.rank}.`), u != null && k(u.rank === 2 || u.rank === 1, () => `Error in batchNorm2D: scale must be rank 2 or rank 1 but got rank ${u.rank}.`), c != null && k(c.rank === 2 || c.rank === 1, () => `Error in batchNorm2D: offset must be rank 2 or rank 1 but got rank ${c.rank}.`), os(a, o, l, c, u, r);
 }
-const dc = /* @__PURE__ */ F({ batchNorm2d_: pc });
-function fc(s, t, e, n, i, r) {
+const fc = /* @__PURE__ */ F({ batchNorm2d_: dc });
+function mc(s, t, e, n, i, r) {
   const a = D(s, "x", "batchNorm"), o = D(t, "mean", "batchNorm"), l = D(e, "variance", "batchNorm");
   let u;
   i != null && (u = D(i, "scale", "batchNorm"));
   let c;
   return n != null && (c = D(n, "offset", "batchNorm")), k(a.rank === 3, () => `Error in batchNorm3D: x must be rank 3 but got rank ${a.rank}.`), k(o.rank === 3 || o.rank === 1, () => `Error in batchNorm3D: mean must be rank 3 or rank 1 but got rank ${o.rank}.`), k(l.rank === 3 || l.rank === 1, () => `Error in batchNorm3D: variance must be rank 3 or rank 1 but got rank ${l.rank}.`), u != null && k(u.rank === 3 || u.rank === 1, () => `Error in batchNorm3D: scale must be rank 3 or rank 1 but got rank ${u.rank}.`), c != null && k(c.rank === 3 || c.rank === 1, () => `Error in batchNorm3D: offset must be rank 3 or rank 1 but got rank ${c.rank}.`), os(a, o, l, c, u, r);
 }
-const mc = /* @__PURE__ */ F({ batchNorm3d_: fc });
-function gc(s, t, e, n, i, r) {
+const gc = /* @__PURE__ */ F({ batchNorm3d_: mc });
+function bc(s, t, e, n, i, r) {
   const a = D(s, "x", "batchNorm"), o = D(t, "mean", "batchNorm"), l = D(e, "variance", "batchNorm");
   let u;
   i != null && (u = D(i, "scale", "batchNorm"));
   let c;
   return n != null && (c = D(n, "offset", "batchNorm")), k(a.rank === 4, () => `Error in batchNorm4D: x must be rank 4 but got rank ${a.rank}.`), k(o.rank === 4 || o.rank === 1, () => `Error in batchNorm4D: mean must be rank 4 or rank 1 but got rank ${o.rank}.`), k(l.rank === 4 || l.rank === 1, () => `Error in batchNorm4D: variance must be rank 4 or rank 1 but got rank ${l.rank}.`), u != null && k(u.rank === 4 || u.rank === 1, () => `Error in batchNorm4D: scale must be rank 4 or rank 1 but got rank ${u.rank}.`), c != null && k(c.rank === 4 || c.rank === 1, () => `Error in batchNorm4D: offset must be rank 4 or rank 1 but got rank ${c.rank}.`), os(a, o, l, c, u, r);
 }
-const bc = /* @__PURE__ */ F({ batchNorm4d_: gc });
+const yc = /* @__PURE__ */ F({ batchNorm4d_: bc });
 /**
  * @license
  * Copyright 2020 Google LLC. All Rights Reserved.
@@ -379,7 +380,7 @@ const bc = /* @__PURE__ */ F({ batchNorm4d_: gc });
  * limitations under the License.
  * =============================================================================
  */
-function yc(s, t, e, n, i = "NHWC", r = [1, 1], a) {
+function wc(s, t, e, n, i = "NHWC", r = [1, 1], a) {
   const o = D(s, "x", "conv2d", "float32"), l = D(t, "filter", "conv2d", "float32");
   let u = o, c = !1;
   o.rank === 3 && (c = !0, u = A(o, [1, o.shape[0], o.shape[1], o.shape[2]])), k(u.rank === 4, () => `Error in conv2d: input must be rank 4, but got rank ${u.rank}.`), k(l.rank === 4, () => `Error in conv2d: filter must be rank 4, but got rank ${l.rank}.`), ft("conv2d", n, a);
@@ -388,15 +389,15 @@ function yc(s, t, e, n, i = "NHWC", r = [1, 1], a) {
   const p = { x: u, filter: l }, f = { strides: e, pad: n, dataFormat: i, dilations: r, dimRoundingMode: a }, g = M.runKernel(xi, p, f);
   return c ? A(g, [g.shape[1], g.shape[2], g.shape[3]]) : g;
 }
-const Ce = /* @__PURE__ */ F({ conv2d_: yc });
-function wc(s, t, e, n, i = "NWC", r = 1, a) {
+const Ce = /* @__PURE__ */ F({ conv2d_: wc });
+function kc(s, t, e, n, i = "NWC", r = 1, a) {
   const o = D(s, "x", "conv1d"), l = D(t, "filter", "conv1d");
   let u = o, c = !1;
   o.rank === 2 && (c = !0, u = A(o, [1, o.shape[0], o.shape[1]])), k(u.rank === 3, () => `Error in conv1d: input must be rank 3, but got rank ${u.rank}.`), k(l.rank === 3, () => `Error in conv1d: filter must be rank 3, but got rank ${l.rank}.`), ft("conv1d", n, a), k(u.shape[2] === l.shape[1], () => `Error in conv1d: depth of input (${u.shape[2]}) must match input depth for filter ${l.shape[1]}.`), k(de(e, r), () => `Error in conv1D: Either stride or dilation must be 1. Got stride ${e} and dilation '${r}'`), k(Ae(r), () => "Error in conv1D: Dilated rates should be larger than 0."), k(Ae(e), () => "Error in conv1D: Stride should be larger than 0."), k(i === "NWC", () => `Error in conv1d: got dataFormat of ${i} but only NWC is currently supported.`);
   const h = A(l, [1, l.shape[0], l.shape[1], l.shape[2]]), p = A(u, [u.shape[0], 1, u.shape[1], u.shape[2]]), m = Ce(p, h, [1, e], n, "NHWC", [1, r], a);
   return c ? A(m, [m.shape[2], m.shape[3]]) : A(m, [m.shape[0], m.shape[2], m.shape[3]]);
 }
-const kc = /* @__PURE__ */ F({ conv1d_: wc });
+const xc = /* @__PURE__ */ F({ conv1d_: kc });
 /**
  * @license
  * Copyright 2020 Google LLC. All Rights Reserved.
@@ -413,21 +414,21 @@ const kc = /* @__PURE__ */ F({ conv1d_: wc });
  * limitations under the License.
  * =============================================================================
  */
-function xc(s, t, e, n, i, r = "NHWC", a) {
+function Nc(s, t, e, n, i, r = "NHWC", a) {
   k(s.length === t.rank, () => `Length of inShape (${s.length}) and rank of dy (${t.rank}) must match`);
   let o = s, l = t, u = !1;
   t.rank === 3 && (u = !0, l = A(t, [1, t.shape[0], t.shape[1], t.shape[2]]), o = [1, s[0], s[1], s[2]]), k(o.length === 4, () => `Error in conv2dDerInput: inShape must be length 4, but got length ${o.length}.`), k(l.rank === 4, () => `Error in conv2dDerInput: dy must be rank 4, but got rank ${l.rank}`), k(e.rank === 4, () => `Error in conv2dDerInput: filter must be rank 4, but got rank ${e.rank}`);
   const c = r === "NHWC" ? o[3] : o[1], h = r === "NHWC" ? l.shape[3] : l.shape[1];
   k(c === e.shape[2], () => `Error in conv2dDerInput: depth of input (${c}) must match input depth for filter ${e.shape[2]}.`), k(h === e.shape[3], () => `Error in conv2dDerInput: depth of output (${h}) must match output depth for filter ${e.shape[3]}.`), ft("conv2dDerInput", i, a);
-  const p = { dy: l, filter: e }, f = { strides: n, pad: i, dataFormat: r, dimRoundingMode: a, inputShape: o }, g = M.runKernel(vi, p, f);
+  const p = { dy: l, filter: e }, f = { strides: n, pad: i, dataFormat: r, dimRoundingMode: a, inputShape: o }, g = M.runKernel(Ni, p, f);
   return u ? A(g, [g.shape[1], g.shape[2], g.shape[3]]) : g;
 }
-const ls = /* @__PURE__ */ F({ conv2DBackpropInput_: xc });
+const ls = /* @__PURE__ */ F({ conv2DBackpropInput_: Nc });
 function vc(s, t, e, n, i, r) {
   const a = D(s, "x", "conv2dTranspose"), o = D(t, "filter", "conv2dTranspose");
   return ls(e, a, o, n, i, "NHWC", r);
 }
-const Nc = /* @__PURE__ */ F({ conv2dTranspose_: vc });
+const Sc = /* @__PURE__ */ F({ conv2dTranspose_: vc });
 /**
  * @license
  * Copyright 2020 Google LLC. All Rights Reserved.
@@ -444,14 +445,14 @@ const Nc = /* @__PURE__ */ F({ conv2dTranspose_: vc });
  * limitations under the License.
  * =============================================================================
  */
-function Sc(s, t, e, n, i = "NDHWC", r = [1, 1, 1]) {
+function Ac(s, t, e, n, i = "NDHWC", r = [1, 1, 1]) {
   const a = D(s, "x", "conv3d"), o = D(t, "filter", "conv3d");
   let l = a, u = !1;
   a.rank === 4 && (u = !0, l = A(a, [1, a.shape[0], a.shape[1], a.shape[2], a.shape[3]])), k(l.rank === 5, () => `Error in conv3d: input must be rank 5, but got rank ${l.rank}.`), k(o.rank === 5, () => `Error in conv3d: filter must be rank 5, but got rank ${o.rank}.`), k(l.shape[4] === o.shape[3], () => `Error in conv3d: depth of input (${l.shape[4]}) must match input depth for filter ${o.shape[3]}.`), k(de(e, r), () => `Error in conv3D: Either strides or dilations must be 1. Got strides ${e} and dilations '${r}'`), k(i === "NDHWC", () => `Error in conv3d: got dataFormat of ${i} but only NDHWC is currently supported.`), k(Ae(r), () => "Error in conv3D: Dilated rates should be larger than 0."), k(Ae(e), () => "Error in conv3D: Strides should be larger than 0.");
-  const c = { x: l, filter: o }, h = { strides: e, pad: n, dataFormat: i, dilations: r }, p = M.runKernel(Ni, c, h);
+  const c = { x: l, filter: o }, h = { strides: e, pad: n, dataFormat: i, dilations: r }, p = M.runKernel(vi, c, h);
   return u ? A(p, [p.shape[1], p.shape[2], p.shape[3], p.shape[4]]) : p;
 }
-const Ac = /* @__PURE__ */ F({ conv3d_: Sc });
+const Cc = /* @__PURE__ */ F({ conv3d_: Ac });
 /**
  * @license
  * Copyright 2020 Google LLC. All Rights Reserved.
@@ -468,7 +469,7 @@ const Ac = /* @__PURE__ */ F({ conv3d_: Sc });
  * limitations under the License.
  * =============================================================================
  */
-function Cc(s, t, e, n, i) {
+function Ic(s, t, e, n, i) {
   k(s.length === t.rank, () => `Length of inShape (${s.length}) and rank of dy (${t.rank}) must match`);
   let r = s, a = t, o = !1;
   t.rank === 4 && (o = !0, a = A(t, [1, t.shape[0], t.shape[1], t.shape[2], t.shape[3]]), r = [1, s[0], s[1], s[2], s[3]]);
@@ -477,12 +478,12 @@ function Cc(s, t, e, n, i) {
   const c = { dy: a, filter: e }, h = { pad: i, strides: n, inputShape: r }, p = M.runKernel(go, c, h);
   return o ? A(p, [p.shape[1], p.shape[2], p.shape[3], p.shape[4]]) : p;
 }
-const er = /* @__PURE__ */ F({ conv3DBackpropInput_: Cc });
-function Ic(s, t, e, n, i) {
+const er = /* @__PURE__ */ F({ conv3DBackpropInput_: Ic });
+function Dc(s, t, e, n, i) {
   const r = D(s, "x", "conv3dTranspose"), a = D(t, "filter", "conv3dTranspose");
   return er(e, r, a, n, i);
 }
-const Dc = /* @__PURE__ */ F({ conv3dTranspose_: Ic });
+const zc = /* @__PURE__ */ F({ conv3dTranspose_: Dc });
 /**
  * @license
  * Copyright 2018 Google LLC. All Rights Reserved.
@@ -499,11 +500,11 @@ const Dc = /* @__PURE__ */ F({ conv3dTranspose_: Ic });
  * limitations under the License.
  * =============================================================================
  */
-function zc(s) {
+function Tc(s) {
   const e = { x: D(s, "x", "cosh", "float32") };
   return M.runKernel(Si, e);
 }
-const Tc = /* @__PURE__ */ F({ cosh_: zc });
+const $c = /* @__PURE__ */ F({ cosh_: Tc });
 /**
  * @license
  * Copyright 2022 Google LLC. All Rights Reserved.
@@ -520,11 +521,11 @@ const Tc = /* @__PURE__ */ F({ cosh_: zc });
  * limitations under the License.
  * =============================================================================
  */
-function $c(s, t = 0, e = !1, n = !1) {
+function Ec(s, t = 0, e = !1, n = !1) {
   const r = { x: D(s, "x", "cumprod") }, a = { axis: t, exclusive: e, reverse: n };
   return M.runKernel(bo, r, a);
 }
-const Ps = /* @__PURE__ */ F({ cumprod_: $c });
+const Ps = /* @__PURE__ */ F({ cumprod_: Ec });
 /**
  * @license
  * Copyright 2018 Google LLC. All Rights Reserved.
@@ -541,11 +542,11 @@ const Ps = /* @__PURE__ */ F({ cumprod_: $c });
  * limitations under the License.
  * =============================================================================
  */
-function Ec(s, t = 0, e = !1, n = !1) {
+function Lc(s, t = 0, e = !1, n = !1) {
   const r = { x: D(s, "x", "cumsum") }, a = { axis: t, exclusive: e, reverse: n };
   return M.runKernel(Ai, r, a);
 }
-const Lc = /* @__PURE__ */ F({ cumsum_: Ec });
+const Fc = /* @__PURE__ */ F({ cumsum_: Lc });
 /**
  * @license
  * Copyright 2020 Google LLC. All Rights Reserved.
@@ -562,13 +563,13 @@ const Lc = /* @__PURE__ */ F({ cumsum_: Ec });
  * limitations under the License.
  * =============================================================================
  */
-function Fc(s, t, e, n = !1) {
+function Mc(s, t, e, n = !1) {
   const i = D(s, "x", "denseBincount"), r = D(t, "weights", "denseBincount");
   k(i.dtype === "int32", () => `Error in denseBincount: input dtype must be int32, but got ${i.dtype}`), k(i.rank <= 2, () => `Error in denseBincount: input must be at most rank 2, but got rank ${i.rank}.`), k(e >= 0, () => `size must be non-negative, but got ${e}.`), k(r.size === i.size || r.size === 0, () => `Error in denseBincount: weights must have the same shape as x or 0-length, but got x shape: ${i.shape}, weights shape: ${r.shape}.`);
   const a = { x: i, weights: r }, o = { size: e, binaryOutput: n };
   return M.runKernel(yo, a, o);
 }
-const Us = /* @__PURE__ */ F({ denseBincount_: Fc });
+const Us = /* @__PURE__ */ F({ denseBincount_: Mc });
 /**
  * @license
  * Copyright 2020 Google LLC. All Rights Reserved.
@@ -585,7 +586,7 @@ const Us = /* @__PURE__ */ F({ denseBincount_: Fc });
  * limitations under the License.
  * =============================================================================
  */
-function Mc(s, t, e, n, i = "NHWC", r = [1, 1], a) {
+function Oc(s, t, e, n, i = "NHWC", r = [1, 1], a) {
   const o = D(s, "x", "depthwiseConv2d", "float32"), l = D(t, "filter", "depthwiseConv2d", "float32");
   let u = o, c = !1;
   o.rank === 3 && (c = !0, u = A(o, [1, o.shape[0], o.shape[1], o.shape[2]])), k(u.rank === 4, () => `Error in depthwiseConv2d: input must be rank 4, but got rank ${u.rank}.`), k(l.rank === 4, () => `Error in depthwiseConv2d: filter must be rank 4, but got rank ${l.rank}.`);
@@ -594,7 +595,7 @@ function Mc(s, t, e, n, i = "NHWC", r = [1, 1], a) {
   const p = { x: u, filter: l }, f = { strides: e, pad: n, dataFormat: i, dilations: r, dimRoundingMode: a }, g = M.runKernel(Ci, p, f);
   return c ? A(g, [g.shape[1], g.shape[2], g.shape[3]]) : g;
 }
-const nr = /* @__PURE__ */ F({ depthwiseConv2d_: Mc });
+const nr = /* @__PURE__ */ F({ depthwiseConv2d_: Oc });
 /**
  * @license
  * Copyright 2020 Google LLC. All Rights Reserved.
@@ -611,13 +612,13 @@ const nr = /* @__PURE__ */ F({ depthwiseConv2d_: Mc });
  * limitations under the License.
  * =============================================================================
  */
-function Oc(s, t) {
+function Rc(s, t) {
   let e = D(s, "a", "equal", "string_or_numeric"), n = D(t, "b", "equal", "string_or_numeric");
   [e, n] = Hn(e, n), wt(e.shape, n.shape);
   const i = { a: e, b: n };
   return M.runKernel(wo, i);
 }
-const Xt = /* @__PURE__ */ F({ equal_: Oc });
+const Xt = /* @__PURE__ */ F({ equal_: Rc });
 /**
  * @license
  * Copyright 2018 Google LLC. All Rights Reserved.
@@ -634,13 +635,13 @@ const Xt = /* @__PURE__ */ F({ equal_: Oc });
  * limitations under the License.
  * =============================================================================
  */
-function Rc(s) {
+function _c(s) {
   let t = D(s, "x", "erf");
   k(t.dtype === "int32" || t.dtype === "float32", () => "Input dtype must be `int32` or `float32`."), t.dtype === "int32" && (t = L(t, "float32"));
   const e = { x: t };
   return M.runKernel(Ii, e);
 }
-const _c = /* @__PURE__ */ F({ erf_: Rc });
+const Bc = /* @__PURE__ */ F({ erf_: _c });
 /**
  * @license
  * Copyright 2018 Google LLC. All Rights Reserved.
@@ -657,11 +658,11 @@ const _c = /* @__PURE__ */ F({ erf_: Rc });
  * limitations under the License.
  * =============================================================================
  */
-function Bc(s) {
+function Wc(s) {
   const e = { x: D(s, "x", "log1p") };
   return M.runKernel(Di, e);
 }
-const Wc = /* @__PURE__ */ F({ log1p_: Bc });
+const Gc = /* @__PURE__ */ F({ log1p_: Wc });
 /**
  * @license
  * Copyright 2018 Google LLC. All Rights Reserved.
@@ -678,11 +679,11 @@ const Wc = /* @__PURE__ */ F({ log1p_: Bc });
  * limitations under the License.
  * =============================================================================
  */
-function Gc(s) {
+function Pc(s) {
   const e = { x: D(s, "x", "softplus") };
   return M.runKernel(zi, e);
 }
-const us = /* @__PURE__ */ F({ softplus_: Gc });
+const us = /* @__PURE__ */ F({ softplus_: Pc });
 /**
  * @license
  * Copyright 2020 Google Inc. All Rights Reserved.
@@ -699,19 +700,19 @@ const us = /* @__PURE__ */ F({ softplus_: Gc });
  * limitations under the License.
  * =============================================================================
  */
-function Pc(s, t = -1) {
+function Uc(s, t = -1) {
   const e = D(s, "logits", "logSoftmax");
   if (t === -1 && (t = e.rank - 1), t !== e.rank - 1)
     throw Error(`Log Softmax along a non-last dimension is not yet supported. Logits was rank ${e.rank} and axis was ${t}`);
   return On((i, r) => {
-    const o = Ne(i, t, !0), l = V(i, o), u = V(L(l, "float32"), Zt(B(Jt(l), t, !0)));
+    const o = ve(i, t, !0), l = V(i, o), u = V(L(l, "float32"), Zt(B(Jt(l), t, !0)));
     return r([u]), { value: u, gradFunc: (h, p) => {
       const [f] = p, g = !0, b = Jt(f);
       return V(h, w(B(h, t, g), b));
     } };
   })(e);
 }
-const Uc = /* @__PURE__ */ F({ logSoftmax_: Pc });
+const Vc = /* @__PURE__ */ F({ logSoftmax_: Uc });
 /**
  * @license
  * Copyright 2020 Google LLC. All Rights Reserved.
@@ -728,11 +729,11 @@ const Uc = /* @__PURE__ */ F({ logSoftmax_: Pc });
  * limitations under the License.
  * =============================================================================
  */
-function Vc(s) {
+function jc(s) {
   const e = { x: D(s, "x", "logicalNot", "bool") };
   return M.runKernel(ko, e);
 }
-const jc = /* @__PURE__ */ F({ logicalNot_: Vc });
+const Kc = /* @__PURE__ */ F({ logicalNot_: jc });
 /**
  * @license
  * Copyright 2020 Google LLC. All Rights Reserved.
@@ -749,14 +750,14 @@ const jc = /* @__PURE__ */ F({ logicalNot_: Vc });
  * limitations under the License.
  * =============================================================================
  */
-function Kc(s, t, e, n, i) {
+function Hc(s, t, e, n, i) {
   const r = D(s, "x", "maxPool"), a = 1;
   let o = r, l = !1;
   r.rank === 3 && (l = !0, o = A(r, [1, r.shape[0], r.shape[1], r.shape[2]])), k(o.rank === 4, () => `Error in maxPool: input must be rank 4 but got rank ${o.rank}.`), k(de(e, a), () => `Error in maxPool: Either strides or dilations must be 1. Got strides ${e} and dilations '${a}'`), ft("maxPool", n, i);
   const u = { x: o }, c = { filterSize: t, strides: e, pad: n, dimRoundingMode: i }, h = M.runKernel(Ti, u, c);
   return l ? A(h, [h.shape[1], h.shape[2], h.shape[3]]) : h;
 }
-const Hc = /* @__PURE__ */ F({ maxPool_: Kc });
+const qc = /* @__PURE__ */ F({ maxPool_: Hc });
 /**
  * @license
  * Copyright 2020 Google LLC. All Rights Reserved.
@@ -773,14 +774,14 @@ const Hc = /* @__PURE__ */ F({ maxPool_: Kc });
  * limitations under the License.
  * =============================================================================
  */
-function qc(s, t = [1, 1, 1], e, n, i, r = "NDHWC") {
+function Zc(s, t = [1, 1, 1], e, n, i, r = "NDHWC") {
   const a = D(s, "x", "maxPool3d");
   let o = a, l = !1;
   a.rank === 4 && (l = !0, o = A(a, [1, a.shape[0], a.shape[1], a.shape[2], a.shape[3]])), k(o.rank === 5, () => `Error in maxPool3d: x must be rank 5 but got rank ${o.rank}.`), k(r === "NDHWC", () => `Error in maxPool3d: Only NDHWC is currently supported, but got dataFormat of ${r}`), ft("maxPool3d", n, i);
   const u = { x: o }, c = { filterSize: t, strides: e, pad: n, dimRoundingMode: i, dataFormat: r }, h = M.runKernel($i, u, c);
   return l ? A(h, [h.shape[1], h.shape[2], h.shape[3], h.shape[4]]) : h;
 }
-const Zc = /* @__PURE__ */ F({ maxPool3d_: qc });
+const Jc = /* @__PURE__ */ F({ maxPool3d_: Zc });
 /**
  * @license
  * Copyright 2020 Google LLC. All Rights Reserved.
@@ -797,13 +798,13 @@ const Zc = /* @__PURE__ */ F({ maxPool3d_: qc });
  * limitations under the License.
  * =============================================================================
  */
-function Jc(s, t) {
+function Xc(s, t) {
   let e = D(s, "a", "notEqual", "string_or_numeric"), n = D(t, "b", "notEqual", "string_or_numeric");
   [e, n] = Hn(e, n), wt(e.shape, n.shape);
   const i = { a: e, b: n };
   return M.runKernel(xo, i);
 }
-const Bn = /* @__PURE__ */ F({ notEqual_: Jc });
+const Bn = /* @__PURE__ */ F({ notEqual_: Xc });
 /**
  * @license
  * Copyright 2020 Google LLC. All Rights Reserved.
@@ -820,13 +821,13 @@ const Bn = /* @__PURE__ */ F({ notEqual_: Jc });
  * limitations under the License.
  * =============================================================================
  */
-function Xc(s, t, e = 1, n = 0, i = "int32") {
+function Yc(s, t, e = 1, n = 0, i = "int32") {
   if (t < 2)
     throw new Error(`Error in oneHot: depth must be >=2, but it is ${t}`);
   const a = { indices: D(s, "indices", "oneHot", "int32") }, o = { dtype: i, depth: t, onValue: e, offValue: n };
   return M.runKernel(Ei, a, o);
 }
-const Yc = /* @__PURE__ */ F({ oneHot_: Xc });
+const Qc = /* @__PURE__ */ F({ oneHot_: Yc });
 /**
  * @license
  * Copyright 2018 Google LLC. All Rights Reserved.
@@ -843,11 +844,11 @@ const Yc = /* @__PURE__ */ F({ oneHot_: Xc });
  * limitations under the License.
  * =============================================================================
  */
-function Qc(s) {
+function th(s) {
   const e = { x: D(s, "x", "onesLike") };
   return M.runKernel(Li, e);
 }
-const Dt = /* @__PURE__ */ F({ onesLike_: Qc });
+const Dt = /* @__PURE__ */ F({ onesLike_: th });
 /**
  * @license
  * Copyright 2020 Google LLC. All Rights Reserved.
@@ -864,14 +865,14 @@ const Dt = /* @__PURE__ */ F({ onesLike_: Qc });
  * limitations under the License.
  * =============================================================================
  */
-function th(s, t, e = 0) {
+function eh(s, t, e = 0) {
   const n = D(s, "x", "pad");
   if (n.rank === 0)
     throw new Error("pad(scalar) is not defined. Pass non-scalar to pad");
   const i = { paddings: t, constantValue: e }, r = { x: n };
   return M.runKernel(Fi, r, i);
 }
-const sr = /* @__PURE__ */ F({ pad_: th });
+const sr = /* @__PURE__ */ F({ pad_: eh });
 /**
  * @license
  * Copyright 2020 Google LLC. All Rights Reserved.
@@ -888,13 +889,13 @@ const sr = /* @__PURE__ */ F({ pad_: th });
  * limitations under the License.
  * =============================================================================
  */
-function eh(s, t, e) {
+function nh(s, t, e) {
   const n = D(s, "x", "spaceToBatchND");
   k(n.rank >= 1 + t.length, () => `input rank ${n.rank} should be > than [blockShape] ${t.length}`), k(e.length === t.length, () => `paddings.shape[0] ${e.length} must be equal to [blockShape] ${t.length}`), k(n.shape.reduce((a, o, l) => l > 0 && l <= t.length ? a && (o + e[l - 1][0] + e[l - 1][1]) % t[l - 1] === 0 : a, !0), () => `input spatial dimensions ${n.shape.slice(1)} with paddings ${e.toString()} must be divisible by blockShapes ${t.toString()}`);
   const i = { x: n }, r = { blockShape: t, paddings: e };
   return M.runKernel(Mi, i, r);
 }
-const nh = /* @__PURE__ */ F({ spaceToBatchND_: eh });
+const sh = /* @__PURE__ */ F({ spaceToBatchND_: nh });
 /**
  * @license
  * Copyright 2018 Google LLC. All Rights Reserved.
@@ -911,11 +912,11 @@ const nh = /* @__PURE__ */ F({ spaceToBatchND_: eh });
  * limitations under the License.
  * =============================================================================
  */
-function sh(s, t) {
+function ih(s, t) {
   const n = { x: D(s, "x", "reverse") }, i = { dims: t };
   return M.runKernel(Oi, n, i);
 }
-const on = /* @__PURE__ */ F({ reverse_: sh });
+const on = /* @__PURE__ */ F({ reverse_: ih });
 /**
  * @license
  * Copyright 2018 Google LLC. All Rights Reserved.
@@ -932,11 +933,11 @@ const on = /* @__PURE__ */ F({ reverse_: sh });
  * limitations under the License.
  * =============================================================================
  */
-function ih(s) {
+function rh(s) {
   const e = { x: D(s, "x", "rsqrt", "float32") };
   return M.runKernel(Ri, e);
 }
-const rh = /* @__PURE__ */ F({ rsqrt_: ih });
+const ah = /* @__PURE__ */ F({ rsqrt_: rh });
 /**
  * @license
  * Copyright 2020 Google LLC. All Rights Reserved.
@@ -953,12 +954,12 @@ const rh = /* @__PURE__ */ F({ rsqrt_: ih });
  * limitations under the License.
  * =============================================================================
  */
-function ah(s) {
+function oh(s) {
   const e = { x: D(s, "x", "selu") };
   return M.runKernel(_i, e);
 }
-const oh = /* @__PURE__ */ F({ selu_: ah });
-function lh(s, t, e, n, i, r = [1, 1], a = "NHWC") {
+const lh = /* @__PURE__ */ F({ selu_: oh });
+function uh(s, t, e, n, i, r = [1, 1], a = "NHWC") {
   const o = D(s, "x", "separableConv2d"), l = D(t, "depthwiseFilter", "separableConv2d"), u = D(e, "pointwiseFilter", "separableConv2d");
   let c = o, h = !1;
   if (o.rank === 3 && (h = !0, c = A(o, [1, o.shape[0], o.shape[1], o.shape[2]])), a === "NCHW")
@@ -969,7 +970,7 @@ function lh(s, t, e, n, i, r = [1, 1], a = "NHWC") {
   const g = nr(c, l, n, i, a, r), m = Ce(g, u, 1, "valid", a);
   return h ? A(m, [m.shape[1], m.shape[2], m.shape[3]]) : m;
 }
-const uh = /* @__PURE__ */ F({ separableConv2d_: lh });
+const ch = /* @__PURE__ */ F({ separableConv2d_: uh });
 /**
  * @license
  * Copyright 2018 Google LLC. All Rights Reserved.
@@ -986,11 +987,11 @@ const uh = /* @__PURE__ */ F({ separableConv2d_: lh });
  * limitations under the License.
  * =============================================================================
  */
-function ch(s) {
+function hh(s) {
   const e = { x: D(s, "x", "sinh") };
   return M.runKernel(Bi, e);
 }
-const hh = /* @__PURE__ */ F({ sinh_: ch });
+const ph = /* @__PURE__ */ F({ sinh_: hh });
 /**
  * @license
  * Copyright 2020 Google LLC. All Rights Reserved.
@@ -1007,15 +1008,15 @@ const hh = /* @__PURE__ */ F({ sinh_: ch });
  * limitations under the License.
  * =============================================================================
  */
-function ph(s, t = 0, e = 1, n, i) {
-  if (vo(s), n != null && n === "bool")
+function dh(s, t = 0, e = 1, n, i) {
+  if (No(s), n != null && n === "bool")
     throw new Error("Unsupported data type $ { dtype }");
-  const r = new Gu(t, e, n, !0, i), a = No(s, n);
+  const r = new _u(t, e, n, !0, i), a = vo(s, n);
   for (let o = 0; o < a.values.length; o++)
     a.values[o] = r.nextValue();
   return a.toTensor();
 }
-const ir = /* @__PURE__ */ F({ truncatedNormal_: ph });
+const ir = /* @__PURE__ */ F({ truncatedNormal_: dh });
 /**
  * @license
  * Copyright 2020 Google LLC. All Rights Reserved.
@@ -1032,13 +1033,13 @@ const ir = /* @__PURE__ */ F({ truncatedNormal_: ph });
  * limitations under the License.
  * =============================================================================
  */
-function dh(s, t, e) {
+function fh(s, t, e) {
   const n = D(s, "x", "unsortedSegmentSum"), i = D(t, "segmentIds", "unsortedSegmentSum", "int32");
   k(Mn(e), () => "numSegments must be of dtype int");
   const r = { x: n, segmentIds: i }, a = { numSegments: e };
   return M.runKernel(Wi, r, a);
 }
-const fh = /* @__PURE__ */ F({ unsortedSegmentSum_: dh });
+const mh = /* @__PURE__ */ F({ unsortedSegmentSum_: fh });
 /**
  * @license
  * Copyright 2020 Google LLC. All Rights Reserved.
@@ -1055,7 +1056,7 @@ const fh = /* @__PURE__ */ F({ unsortedSegmentSum_: dh });
  * limitations under the License.
  * =============================================================================
  */
-function mh(s, t, e, n, i, r = "NHWC", a) {
+function gh(s, t, e, n, i, r = "NHWC", a) {
   let o = s;
   s.rank === 3 && (o = A(s, [1, s.shape[0], s.shape[1], s.shape[2]]));
   let l = t;
@@ -1065,7 +1066,7 @@ function mh(s, t, e, n, i, r = "NHWC", a) {
   const h = { x: o, dy: l }, p = { strides: n, pad: i, dataFormat: r, dimRoundingMode: a, filterShape: e };
   return M.runKernel(So, h, p);
 }
-const cs = /* @__PURE__ */ F({ conv2DBackpropFilter_: mh });
+const cs = /* @__PURE__ */ F({ conv2DBackpropFilter_: gh });
 /**
  * @license
  * Copyright 2019 Google LLC. All Rights Reserved.
@@ -1082,7 +1083,7 @@ const cs = /* @__PURE__ */ F({ conv2DBackpropFilter_: mh });
  * limitations under the License.
  * =============================================================================
  */
-function gh({ x: s, filter: t, strides: e, pad: n, dataFormat: i = "NHWC", dilations: r = [1, 1], dimRoundingMode: a, bias: o, activation: l = "linear", preluActivationWeights: u, leakyreluAlpha: c }) {
+function bh({ x: s, filter: t, strides: e, pad: n, dataFormat: i = "NHWC", dilations: r = [1, 1], dimRoundingMode: a, bias: o, activation: l = "linear", preluActivationWeights: u, leakyreluAlpha: c }) {
   if (l = l || "linear", ku(M.state.gradientDepth, l) === !1) {
     k(i === "NHWC", () => `Error in fused conv2d: got dataFormat of ${i} but only NHWC is currently supported for the case of gradient depth is 0 and the activation is not linear.`);
     let z = Ce(s, t, e, n, i, r, a);
@@ -1093,9 +1094,9 @@ function gh({ x: s, filter: t, strides: e, pad: n, dataFormat: i = "NHWC", dilat
   h.rank === 3 && (g = !0, f = A(h, [1, h.shape[0], h.shape[1], h.shape[2]])), k(f.rank === 4, () => `Error in fused conv2d: input must be rank 4, but got rank ${f.rank}.`), k(p.rank === 4, () => `Error in fused conv2d: filter must be rank 4, but got rank ${p.rank}.`), ft("fused conv2d", n, a);
   const b = i === "NHWC" ? f.shape[3] : f.shape[1];
   k(p.shape[2] === b, () => `Error in conv2d: depth of input (${b}) must match input depth for filter ${p.shape[2]}.`), k(de(e, r), () => `Error in conv2D: Either strides or dilations must be 1. Got strides ${e} and dilations '${r}'`);
-  const m = Qu(f.shape, p.shape, e, r, n, a);
-  let N;
-  o != null && (N = D(o, "bias", "fused conv2d"), [N] = Hn(N, h), i === "NHWC" ? wt(m.outShape, N.shape) : (k(N.shape.length <= 1, () => `Error in fused conv2d: only supports scalar or 1-D Tensor bias for NCHW format but got the bias of rank-${N.shape.length}.`), k(N.shape.length === 0 || N.shape[0] === m.outChannels || N.shape[0] === 1, () => `Error in fused conv2d: bias shape (${N.shape}) is not compatible with the number of output channels (${m.outChannels})`)));
+  const m = tc(f.shape, p.shape, e, r, n, a);
+  let v;
+  o != null && (v = D(o, "bias", "fused conv2d"), [v] = Hn(v, h), i === "NHWC" ? wt(m.outShape, v.shape) : (k(v.shape.length <= 1, () => `Error in fused conv2d: only supports scalar or 1-D Tensor bias for NCHW format but got the bias of rank-${v.shape.length}.`), k(v.shape.length === 0 || v.shape[0] === m.outChannels || v.shape[0] === 1, () => `Error in fused conv2d: bias shape (${v.shape}) is not compatible with the number of output channels (${m.outChannels})`)));
   let y;
   if (u != null) {
     const z = u.shape;
@@ -1112,18 +1113,18 @@ function gh({ x: s, filter: t, strides: e, pad: n, dataFormat: i = "NHWC", dilat
   }
   const C = (z, _) => {
     k(i === "NHWC", () => `Error in gradient of fused conv2D: got dataFormat of ${i} but only NHWC is currently supported.`);
-    const [T, E, R, q] = _, bt = vu(z, R, l);
+    const [T, E, R, q] = _, bt = Nu(z, R, l);
     k(Se(r), () => `Error in gradient of fused conv2D: dilation rates greater than 1 are not yet supported in gradients. Got dilations '${r}'`);
     const ie = ls(E.shape, bt, T, e, n), re = cs(E, bt, T.shape, e, n), xt = [ie, re];
     if (q != null) {
-      const Tt = Nu(q, bt);
+      const Tt = vu(q, bt);
       xt.push(Tt);
     }
     return xt;
-  }, v = {
+  }, N = {
     x: f,
     filter: p,
-    bias: N,
+    bias: v,
     preluActivationWeights: y
   }, I = {
     strides: e,
@@ -1137,15 +1138,15 @@ function gh({ x: s, filter: t, strides: e, pad: n, dataFormat: i = "NHWC", dilat
   return o == null ? On((_, T, E) => {
     let R = (
       // tslint:disable-next-line: no-unnecessary-type-assertion
-      M.runKernel(Ls, v, I)
+      M.runKernel(Ls, N, I)
     );
     return E([T, _, R]), g && (R = A(R, [R.shape[1], R.shape[2], R.shape[3]])), { value: R, gradFunc: C };
   })(f, p) : On((_, T, E, R) => {
-    let q = M.runKernel(Ls, v, I);
+    let q = M.runKernel(Ls, N, I);
     return R([T, _, q, E]), g && (q = A(q, [q.shape[1], q.shape[2], q.shape[3]])), { value: q, gradFunc: C };
-  })(f, p, N);
+  })(f, p, v);
 }
-const bh = /* @__PURE__ */ F({ fusedConv2d_: gh });
+const yh = /* @__PURE__ */ F({ fusedConv2d_: bh });
 /**
  * @license
  * Copyright 2020 Google LLC. All Rights Reserved.
@@ -1162,7 +1163,7 @@ const bh = /* @__PURE__ */ F({ fusedConv2d_: gh });
  * limitations under the License.
  * =============================================================================
  */
-function yh(s, t, e, n, i, r = [1, 1], a) {
+function wh(s, t, e, n, i, r = [1, 1], a) {
   let o = s;
   s.rank === 3 && (o = A(s, [1, s.shape[0], s.shape[1], s.shape[2]]));
   let l = t;
@@ -1170,7 +1171,7 @@ function yh(s, t, e, n, i, r = [1, 1], a) {
   const u = { x: o, dy: l }, c = { strides: n, pad: i, dimRoundingMode: a, dilations: r, filterShape: e };
   return M.runKernel(Ao, u, c);
 }
-const wh = F({ depthwiseConv2dNativeBackpropFilter_: yh });
+const kh = F({ depthwiseConv2dNativeBackpropFilter_: wh });
 /**
  * @license
  * Copyright 2020 Google LLC. All Rights Reserved.
@@ -1187,7 +1188,7 @@ const wh = F({ depthwiseConv2dNativeBackpropFilter_: yh });
  * limitations under the License.
  * =============================================================================
  */
-function kh(s, t, e, n, i, r = [1, 1], a) {
+function xh(s, t, e, n, i, r = [1, 1], a) {
   let o = t, l = !1;
   t.rank === 3 && (l = !0, o = A(t, [1, t.shape[0], t.shape[1], t.shape[2]]));
   const u = { dy: o, filter: e }, c = { strides: n, pad: i, dimRoundingMode: a, dilations: r, inputShape: s }, h = (
@@ -1196,7 +1197,7 @@ function kh(s, t, e, n, i, r = [1, 1], a) {
   );
   return l ? A(h, [h.shape[1], h.shape[2], h.shape[3]]) : h;
 }
-const xh = F({ depthwiseConv2dNativeBackpropInput_: kh });
+const Nh = F({ depthwiseConv2dNativeBackpropInput_: xh });
 /**
  * @license
  * Copyright 2018 Google LLC. All Rights Reserved.
@@ -1394,9 +1395,9 @@ const ge = vh;
  * limitations under the License.
  * =============================================================================
  */
-const Nh = typeof requestAnimationFrame < "u" ? requestAnimationFrame : typeof setImmediate < "u" ? setImmediate : (s) => s();
-function Sh() {
-  return new Promise((s) => Nh(() => s()));
+const Sh = typeof requestAnimationFrame < "u" ? requestAnimationFrame : typeof setImmediate < "u" ? setImmediate : (s) => s();
+function Ah() {
+  return new Promise((s) => Sh(() => s()));
 }
 /**
  * @license
@@ -1414,7 +1415,7 @@ function Sh() {
  * limitations under the License.
  * =============================================================================
  */
-const Ah = 1.7580993408473768, Ch = 1.0507009873554805;
+const Ch = 1.7580993408473768, Ih = 1.0507009873554805;
 /**
  * @license
  * Copyright 2022 Google LLC
@@ -1478,9 +1479,9 @@ class rr {
  * https://opensource.org/licenses/MIT.
  * =============================================================================
  */
-let Ih = 0;
+let Dh = 0;
 function ar() {
-  return Ih++;
+  return Dh++;
 }
 const Qe = {};
 function xn(s = "") {
@@ -1495,7 +1496,7 @@ function xn(s = "") {
  * https://opensource.org/licenses/MIT.
  * =============================================================================
  */
-const Dh = ["fanIn", "fanOut", "fanAvg"], zh = ["normal", "uniform", "truncatedNormal"];
+const zh = ["fanIn", "fanOut", "fanAvg"], Th = ["normal", "uniform", "truncatedNormal"];
 /**
  * @license
  * Copyright 2018 Google LLC
@@ -1505,11 +1506,11 @@ const Dh = ["fanIn", "fanOut", "fanAvg"], zh = ["normal", "uniform", "truncatedN
  * https://opensource.org/licenses/MIT.
  * =============================================================================
  */
-function Th(s) {
-  Zn(Dh, "FanMode", s);
-}
 function $h(s) {
-  Zn(zh, "Distribution", s);
+  Zn(zh, "FanMode", s);
+}
+function Eh(s) {
+  Zn(Th, "Distribution", s);
 }
 class kt extends Be {
   fromConfigUsesCustomObjects() {
@@ -1603,7 +1604,7 @@ class hr extends kt {
     return x(() => {
       if (t.length !== 2 || t[0] !== t[1])
         throw new d("Identity matrix initializer can only be used for 2D square matrices.");
-      return w(this.gain, Su(t[0]));
+      return w(this.gain, Bu(t[0]));
     });
   }
   getConfig() {
@@ -1612,7 +1613,7 @@ class hr extends kt {
 }
 hr.className = "Identity";
 S(hr);
-function Eh(s, t = "channelsLast") {
+function Lh(s, t = "channelsLast") {
   let e, n;
   if (et(t), s.length === 2)
     e = s[0], n = s[1];
@@ -1638,10 +1639,10 @@ class dt extends kt {
   constructor(t) {
     if (super(), t.scale < 0)
       throw new d(`scale must be a positive float. Got: ${t.scale}`);
-    this.scale = t.scale == null ? 1 : t.scale, this.mode = t.mode == null ? "fanIn" : t.mode, Th(this.mode), this.distribution = t.distribution == null ? "normal" : t.distribution, $h(this.distribution), this.seed = t.seed;
+    this.scale = t.scale == null ? 1 : t.scale, this.mode = t.mode == null ? "fanIn" : t.mode, $h(this.mode), this.distribution = t.distribution == null ? "normal" : t.distribution, Eh(this.distribution), this.seed = t.seed;
   }
   apply(t, e) {
-    const n = Eh(t), i = n[0], r = n[1];
+    const n = Lh(t), i = n[0], r = n[1];
     let a = this.scale;
     if (this.mode === "fanIn" ? a /= Math.max(1, i) : this.mode === "fanOut" ? a /= Math.max(1, r) : a /= Math.max(1, (i + r) / 2), this.distribution === "normal") {
       const o = Math.sqrt(a);
@@ -1781,7 +1782,7 @@ class pr extends kt {
       e = e;
       const n = Gi(t.slice(0, -1)), i = t[t.length - 1], r = n * i;
       r > this.ELEMENTS_WARN_SLOW && console.warn(`Orthogonal initializer is being called on a matrix with more than ${this.ELEMENTS_WARN_SLOW} (${r}) elements: Slowness may result.`);
-      const a = [Math.max(i, n), Math.min(i, n)], o = bn(a, 0, 1, e, this.seed), l = Au.qr(o, !1);
+      const a = [Math.max(i, n), Math.min(i, n)], o = bn(a, 0, 1, e, this.seed), l = Wu.qr(o, !1);
       let u = l[0];
       const h = l[1].flatten().stridedSlice([0], [Math.min(i, n) * Math.min(i, n)], [Math.min(i, n) + 1]);
       return u = w(u, h.sign()), n < i && (u = u.transpose()), w(tt(this.gain), u.reshape(t));
@@ -1898,7 +1899,7 @@ function un(s) {
  * =============================================================================
  */
 const Ks = "Variable";
-class Lh {
+class Fh {
   /**
    * Construct Variable from a `tf.Tensor`.
    *
@@ -1934,7 +1935,7 @@ class Lh {
    * @return This Variable.
    */
   write(t) {
-    return this.assertNotDisposed(), Fh(this.val, t), this.val.id !== t.id && (this.val.assign(t), this.constraint != null && this.val.assign(this.constraint.apply(this.val))), this;
+    return this.assertNotDisposed(), Mh(this.val, t), this.val.id !== t.id && (this.val.assign(t), this.constraint != null && this.val.assign(this.constraint.apply(this.val))), this;
   }
   /**
    * Dispose this LayersVariable instance from memory.
@@ -1953,7 +1954,7 @@ class Lh {
     this.trainable_ = t, this.val.trainable = t;
   }
 }
-function Fh(s, t) {
+function Mh(s, t) {
   if (s.shape.toString() !== t.shape.toString())
     throw new Error("Shape mismatch: " + JSON.stringify(s.shape) + " vs. " + JSON.stringify(t.shape));
 }
@@ -1997,10 +1998,10 @@ class Mt {
     this.dtype = t, this.shape = e, this.sourceLayer = n, this.inputs = i, this.callArgs = r, this.outputTensorIndex = o, this.id = ar(), a != null && (this.originalName = Pi(a), this.name = Ui(this.originalName)), this.rank = e.length;
   }
 }
-let Mh = 0;
-class vn {
+let Oh = 0;
+class Nn {
   constructor(t, e) {
-    this.callArgs = e, this.id = Mh++, this.outboundLayer = t.outboundLayer, this.inboundLayers = t.inboundLayers, this.nodeIndices = t.nodeIndices, this.tensorIndices = t.tensorIndices, this.inputTensors = t.inputTensors, this.outputTensors = t.outputTensors, this.inputMasks = t.inputMasks, this.outputMasks = t.outputMasks, this.inputShapes = t.inputShapes, this.outputShapes = t.outputShapes;
+    this.callArgs = e, this.id = Oh++, this.outboundLayer = t.outboundLayer, this.inboundLayers = t.inboundLayers, this.nodeIndices = t.nodeIndices, this.tensorIndices = t.tensorIndices, this.inputTensors = t.inputTensors, this.outputTensors = t.outputTensors, this.inputMasks = t.inputMasks, this.outputMasks = t.outputMasks, this.inputShapes = t.inputShapes, this.outputShapes = t.outputShapes;
     for (const n of t.inboundLayers)
       n?.outboundNodes.push(this);
     t.outboundLayer.inboundNodes.push(this);
@@ -2017,10 +2018,10 @@ class vn {
     };
   }
 }
-let Oh = 0;
+let Rh = 0;
 class W extends Be {
   constructor(t = {}) {
-    super(), this._callHook = null, this._addedWeightNames = [], this._stateful = !1, this.id = Oh++, this.activityRegularizer = null, this.inputSpec = null, this.supportsMasking = !1, this._trainableWeights = [], this._nonTrainableWeights = [], this._losses = [], this._updates = [], this._built = !1, this.inboundNodes = [], this.outboundNodes = [];
+    super(), this._callHook = null, this._addedWeightNames = [], this._stateful = !1, this.id = Rh++, this.activityRegularizer = null, this.inputSpec = null, this.supportsMasking = !1, this._trainableWeights = [], this._nonTrainableWeights = [], this._losses = [], this._updates = [], this._built = !1, this.inboundNodes = [], this.outboundNodes = [];
     let e = t.name;
     if (!e) {
       const n = this.getClassName();
@@ -2334,7 +2335,7 @@ class W extends Be {
   // Porting Note: This is a replacement for __call__() in Python.
   apply(t, e) {
     e = e || {}, this.assertNotDisposed();
-    const n = K(t), i = Bh(t), r = Wh(t);
+    const n = K(t), i = Wh(t), r = Gh(t);
     if (i === r)
       throw new d("Arguments to apply() must be all SymbolicTensors or all Tensors");
     return le(this.name, () => {
@@ -2355,9 +2356,9 @@ class W extends Be {
           throw new G("Layer invocation in the presence of activity regularizer(s) is not supported yet.");
         return a;
       } else {
-        const a = Rh(t), o = this.computeOutputShape(a);
+        const a = _h(t), o = this.computeOutputShape(a);
         let l;
-        const u = _h(t);
+        const u = Bh(t);
         if (this.warnOnIncompatibleInputShape(Array.isArray(t) ? a[0] : a), o != null && o.length > 0 && Array.isArray(o[0]) ? l = o.map((c, h) => new Mt(u, c, this, K(t), e, this.name, h)) : l = new Mt(u, o, this, K(t), e, this.name), this.addInboundNode(t, l, null, null, a, o, e), this._refCount++, this.activityRegularizer != null)
           throw new G("Layer invocation in the presence of activity regularizer(s) is not supported yet.");
         return l;
@@ -2496,7 +2497,7 @@ class W extends Be {
     if (this._addedWeightNames.indexOf(t) !== -1)
       throw new d(`Duplicate weight name ${t} for layer ${this.name}`);
     this._addedWeightNames.push(t), n == null && (n = "float32"), this.fastWeightInitDuringBuild && (i = l != null ? l() : J("zeros"));
-    const u = i.apply(e, n), c = new Lh(u, n, t, a, o);
+    const u = i.apply(e, n), c = new Fh(u, n, t, a, o);
     return u.dispose(), r != null && this.addLoss(() => r.apply(c.read())), a == null && (a = !0), a ? this._trainableWeights.push(c) : this._nonTrainableWeights.push(c), c;
   }
   /**
@@ -2587,7 +2588,7 @@ class W extends Be {
     const u = [], c = [], h = [];
     for (const p of l)
       u.push(p.sourceLayer), c.push(p.nodeIndex), h.push(p.tensorIndex);
-    new vn({
+    new Nn({
       outboundLayer: this,
       inboundLayers: u,
       nodeIndices: c,
@@ -2679,14 +2680,14 @@ class W extends Be {
     return --this._refCount === 0 && (t = this.disposeWeights()), { refCountAfterDispose: this._refCount, numDisposedVariables: t };
   }
 }
-function Rh(s) {
+function _h(s) {
   s = K(s);
   const t = [];
   for (const e of s)
     t.push(e.shape);
   return ht(t);
 }
-function _h(s) {
+function Bh(s) {
   return "float32";
 }
 function dr(s, t, e) {
@@ -2707,7 +2708,7 @@ function dr(s, t, e) {
     }
   }
 }
-function Bh(s) {
+function Wh(s) {
   let t = !0;
   for (const e of K(s))
     if (!(e instanceof Mt)) {
@@ -2716,7 +2717,7 @@ function Bh(s) {
     }
   return t;
 }
-function Wh(s) {
+function Gh(s) {
   let t = !0;
   for (const e of K(s))
     if (e instanceof Mt) {
@@ -2751,7 +2752,7 @@ class He extends W {
     const n = t.dtype || "float32";
     this.batchInputShape = e, this.dtype = n, this.inputSpec = [{ shape: e }];
     const i = new Mt(this.dtype, this.batchInputShape, this, [], {}, this.name);
-    i.nodeIndex = 0, i.tensorIndex = 0, new vn({
+    i.nodeIndex = 0, i.tensorIndex = 0, new Nn({
       outboundLayer: this,
       inboundLayers: [],
       nodeIndices: [],
@@ -2781,7 +2782,7 @@ class He extends W {
 }
 He.className = "InputLayer";
 S(He);
-function Gh(s) {
+function Ph(s) {
   if (s.batchShape == null && s.shape == null)
     throw new Error("Please provide to Input either a `shape` or a `batchShape` argument. Note that `shape` does not include the batch dimension.");
   if (s.batchShape != null && s.shape != null)
@@ -2805,7 +2806,7 @@ function Gh(s) {
  * https://opensource.org/licenses/MIT.
  * =============================================================================
  */
-function Ph(s, t) {
+function Uh(s, t) {
   if (s.dtype == null || s.dtype === t.dtype)
     return t;
   try {
@@ -2843,7 +2844,7 @@ class Vt {
    */
   add(t, e, n) {
     if (this.id2Value[t.id] == null)
-      this.id2Value[t.id] = Ph(t, e), this.name2Id[t.name] = t.id, n != null && (this.id2Mask[t.id] = n);
+      this.id2Value[t.id] = Uh(t, e), this.name2Id[t.name] = t.id, n != null && (this.id2Mask[t.id] = n);
     else
       throw new d(`Duplicate key: name=${t.name}, id=${t.id}`);
     return this;
@@ -2913,7 +2914,7 @@ class Vt {
   }
 }
 const cn = new rr(), hn = new rr();
-function Uh(s) {
+function Vh(s) {
   cn?.setMaxEntries(s), hn?.setMaxEntries(s);
 }
 function Le(s, t, e, n) {
@@ -2923,7 +2924,7 @@ function Le(s, t, e, n) {
   const c = o.join(",") + "|" + t.names().sort().join(",");
   let h = cn.get(c), p;
   if (h == null) {
-    const g = Vh(a, t);
+    const g = jh(a, t);
     h = g.sorted, p = g.recipientCounts, cn.put(c, h), hn.put(c, p);
   }
   p = {}, i || Object.assign(p, hn.get(c));
@@ -2932,17 +2933,17 @@ function Le(s, t, e, n) {
     const b = h[g], m = b.sourceLayer;
     if (m instanceof He)
       continue;
-    const N = [], y = [], C = [];
-    let v = !1;
+    const v = [], y = [], C = [];
+    let N = !1;
     for (const E of b.inputs) {
       const R = f.getValue(E), q = f.getMask(E);
-      N.push(R), y.push(q), q != null && (v = !0), i || (p[E.name]--, p[E.name] === 0 && !t.hasKey(E) && o.indexOf(E.name) === -1 && !R.isDisposed && E.sourceLayer.stateful !== !0 && C.push(R));
+      v.push(R), y.push(q), q != null && (N = !0), i || (p[E.name]--, p[E.name] === 0 && !t.hasKey(E) && o.indexOf(E.name) === -1 && !R.isDisposed && E.sourceLayer.stateful !== !0 && C.push(R));
     }
-    v && (e = e || {}, e.mask = y[0]);
-    const I = K(m.apply(N, e));
+    N && (e = e || {}, e.mask = y[0]);
+    const I = K(m.apply(v, e));
     let z = null;
-    m.supportsMasking && (z = m.computeMask(N, y));
-    const _ = Kh(b), T = Array.isArray(_) ? _ : [_];
+    m.supportsMasking && (z = m.computeMask(v, y));
+    const _ = Hh(b), T = Array.isArray(_) ? _ : [_];
     for (let E = 0; E < T.length; ++E) {
       f.hasKey(T[E]) || f.add(T[E], I[E], Array.isArray(z) ? z[0] : z);
       const R = o.indexOf(T[E].name);
@@ -2952,7 +2953,7 @@ function Le(s, t, e, n) {
   }
   return f.disposeMasks(), r ? l : l[0];
 }
-function Vh(s, t) {
+function jh(s, t) {
   k(s != null && s.length > 0, () => "Expected at least one fetch, got none");
   let e = [], n = {};
   if (s.length === 1) {
@@ -2970,10 +2971,10 @@ function Vh(s, t) {
   }
   return {
     sorted: e,
-    recipientCounts: jh(n)
+    recipientCounts: Kh(n)
   };
 }
-function jh(s) {
+function Kh(s) {
   const t = {};
   for (const e in s)
     t[e] = s[e].size;
@@ -3001,7 +3002,7 @@ function Hs(s, t) {
   }
   return { sorted: n, recipientMap: i };
 }
-function Kh(s) {
+function Hh(s) {
   let t;
   if (s.sourceLayer.inboundNodes.length === 1)
     t = s.sourceLayer.output;
@@ -3033,8 +3034,8 @@ function Kh(s) {
  * limitations under the License.
  * =============================================================================
  */
-const Hh = Fo();
-Hh.registerFlag("TOPOLOGICAL_SORT_CACHE_MAX_ENTRIES", () => 100, Uh);
+const qh = Fo();
+qh.registerFlag("TOPOLOGICAL_SORT_CACHE_MAX_ENTRIES", () => 100, Vh);
 /**
  * @license
  * Copyright 2020 Google LLC. All Rights Reserved.
@@ -3075,7 +3076,7 @@ const fr = {
  * limitations under the License.
  * =============================================================================
  */
-const qh = {
+const Zh = {
   kernelName: Oo,
   inputsToSave: ["x"],
   gradFunc: (s, t) => {
@@ -3104,7 +3105,7 @@ const qh = {
  * limitations under the License.
  * =============================================================================
  */
-const Zh = {
+const Jh = {
   kernelName: Ro,
   inputsToSave: ["x"],
   gradFunc: (s, t) => {
@@ -3133,7 +3134,7 @@ const Zh = {
  * limitations under the License.
  * =============================================================================
  */
-const Jh = {
+const Xh = {
   kernelName: _o,
   inputsToSave: ["a", "b"],
   gradFunc: (s, t) => {
@@ -3165,7 +3166,7 @@ const Jh = {
  * limitations under the License.
  * =============================================================================
  */
-const Xh = {
+const Yh = {
   kernelName: Bo,
   saveAllInputs: !0,
   gradFunc: (s, t) => {
@@ -3191,7 +3192,7 @@ const Xh = {
  * limitations under the License.
  * =============================================================================
  */
-const Yh = {
+const Qh = {
   kernelName: mi,
   inputsToSave: ["x"],
   gradFunc: (s, t) => {
@@ -3215,7 +3216,7 @@ const Yh = {
  * limitations under the License.
  * =============================================================================
  */
-const Qh = {
+const tp = {
   kernelName: Wo,
   inputsToSave: ["x"],
   gradFunc: (s, t) => {
@@ -3239,7 +3240,7 @@ const Qh = {
  * limitations under the License.
  * =============================================================================
  */
-const tp = {
+const ep = {
   kernelName: Go,
   inputsToSave: ["x"],
   gradFunc: (s, t) => {
@@ -3263,7 +3264,7 @@ const tp = {
  * limitations under the License.
  * =============================================================================
  */
-const ep = {
+const np = {
   kernelName: Po,
   inputsToSave: ["x"],
   gradFunc: (s, t) => {
@@ -3292,7 +3293,7 @@ const ep = {
  * limitations under the License.
  * =============================================================================
  */
-const np = {
+const sp = {
   kernelName: Uo,
   inputsToSave: ["a", "b"],
   gradFunc: (s, t) => {
@@ -3326,7 +3327,7 @@ const np = {
  * limitations under the License.
  * =============================================================================
  */
-const sp = {
+const ip = {
   kernelName: Vo,
   inputsToSave: ["x"],
   gradFunc: (s, t) => {
@@ -3350,7 +3351,7 @@ const sp = {
  * limitations under the License.
  * =============================================================================
  */
-const ip = {
+const rp = {
   kernelName: jo,
   inputsToSave: ["x"],
   gradFunc: (s, t) => {
@@ -3374,7 +3375,7 @@ const ip = {
  * limitations under the License.
  * =============================================================================
  */
-function rp(s, t, e, n, i, r) {
+function ap(s, t, e, n, i, r) {
   const a = D(s, "dy", "avgPool3dGrad"), o = D(t, "input", "avgPool3dGrad");
   let l = a, u = o, c = !1;
   o.rank === 4 && (c = !0, l = A(a, [1, a.shape[0], a.shape[1], a.shape[2], a.shape[3]]), u = A(o, [
@@ -3387,7 +3388,7 @@ function rp(s, t, e, n, i, r) {
   const h = { dy: l, input: u }, p = { filterSize: e, strides: n, pad: i, dimRoundingMode: r }, f = M.runKernel(Ko, h, p);
   return c ? A(f, [f.shape[1], f.shape[2], f.shape[3], f.shape[4]]) : f;
 }
-const ap = /* @__PURE__ */ F({ avgPool3dGrad_: rp });
+const op = /* @__PURE__ */ F({ avgPool3dGrad_: ap });
 /**
  * @license
  * Copyright 2020 Google LLC. All Rights Reserved.
@@ -3404,13 +3405,13 @@ const ap = /* @__PURE__ */ F({ avgPool3dGrad_: rp });
  * limitations under the License.
  * =============================================================================
  */
-const op = {
+const lp = {
   kernelName: bi,
   inputsToSave: ["x"],
   gradFunc: (s, t, e) => {
     const [n] = t, { filterSize: i, strides: r, pad: a, dimRoundingMode: o } = e;
     return {
-      x: () => ap(s, n, i, r, a, o)
+      x: () => op(s, n, i, r, a, o)
     };
   }
 };
@@ -3430,7 +3431,7 @@ const op = {
  * limitations under the License.
  * =============================================================================
  */
-function lp(s, t, e, n, i) {
+function up(s, t, e, n, i) {
   const r = D(s, "dy", "avgPoolGrad"), a = D(t, "input", "avgPoolGrad");
   k(a.rank === r.rank, () => `Rank of input (${a.rank}) does not match rank of dy (${r.rank})`);
   let o = a, l = r, u = !1;
@@ -3438,7 +3439,7 @@ function lp(s, t, e, n, i) {
   const c = { dy: l, input: o }, h = { filterSize: e, strides: n, pad: i }, p = M.runKernel(Ho, c, h);
   return u ? A(p, [p.shape[1], p.shape[2], p.shape[3]]) : p;
 }
-const up = /* @__PURE__ */ F({ avgPoolGrad_: lp });
+const cp = /* @__PURE__ */ F({ avgPoolGrad_: up });
 /**
  * @license
  * Copyright 2020 Google LLC. All Rights Reserved.
@@ -3455,12 +3456,12 @@ const up = /* @__PURE__ */ F({ avgPoolGrad_: lp });
  * limitations under the License.
  * =============================================================================
  */
-const cp = {
+const hp = {
   kernelName: gi,
   inputsToSave: ["x"],
   gradFunc: (s, t, e) => {
     const [n] = t, { filterSize: i, strides: r, pad: a } = e;
-    return { x: () => up(s, n, i, r, a) };
+    return { x: () => cp(s, n, i, r, a) };
   }
 };
 /**
@@ -3479,7 +3480,7 @@ const cp = {
  * limitations under the License.
  * =============================================================================
  */
-const hp = {
+const pp = {
   kernelName: qo,
   inputsToSave: ["a", "b"],
   gradFunc: (s, t, e) => {
@@ -3515,11 +3516,11 @@ const hp = {
  * limitations under the License.
  * =============================================================================
  */
-const pp = {
+const dp = {
   kernelName: wi,
   gradFunc: (s, t, e) => {
     const { blockShape: n, crops: i } = e;
-    return { x: () => nh(s, n, i) };
+    return { x: () => sh(s, n, i) };
   }
 };
 /**
@@ -3538,7 +3539,7 @@ const pp = {
  * limitations under the License.
  * =============================================================================
  */
-const dp = {
+const fp = {
   kernelName: Zo,
   gradFunc: (s, t, e) => {
     const n = e, i = n.inputShape, r = n.shape, a = Array.from(r);
@@ -3574,7 +3575,7 @@ const dp = {
  * limitations under the License.
  * =============================================================================
  */
-const fp = {
+const mp = {
   kernelName: Jo,
   gradFunc: (s) => ({ x: () => s.clone() })
 };
@@ -3594,7 +3595,7 @@ const fp = {
  * limitations under the License.
  * =============================================================================
  */
-const mp = {
+const gp = {
   kernelName: Xo,
   gradFunc: (s) => ({ x: () => Q(s) })
 };
@@ -3614,13 +3615,13 @@ const mp = {
  * limitations under the License.
  * =============================================================================
  */
-const gp = {
+const bp = {
   kernelName: Yo,
   inputsToSave: ["x"],
   gradFunc: (s, t, e) => {
     const [n] = t, { clipValueMin: i, clipValueMax: r } = e;
     return {
-      x: () => Ht(Pe(Ue(n, i), Yn(n, r)), s, Q(s))
+      x: () => qt(je(Ke(n, i), es(n, r)), s, Q(s))
     };
   }
 };
@@ -3640,7 +3641,7 @@ const gp = {
  * limitations under the License.
  * =============================================================================
  */
-const bp = {
+const yp = {
   kernelName: Qo,
   inputsToSave: ["x"],
   gradFunc: fr.gradFunc
@@ -3661,7 +3662,7 @@ const bp = {
  * limitations under the License.
  * =============================================================================
  */
-const yp = {
+const wp = {
   kernelName: tl,
   saveAllInputs: !0,
   gradFunc: (s, t, e) => {
@@ -3685,7 +3686,7 @@ const yp = {
  * limitations under the License.
  * =============================================================================
  */
-const wp = {
+const kp = {
   kernelName: xi,
   inputsToSave: ["x", "filter"],
   gradFunc: (s, t, e) => {
@@ -3712,8 +3713,8 @@ const wp = {
  * limitations under the License.
  * =============================================================================
  */
-const kp = {
-  kernelName: vi,
+const xp = {
+  kernelName: Ni,
   inputsToSave: ["dy", "filter"],
   gradFunc: (s, t, e) => {
     const [n, i] = t, { strides: r, pad: a, dataFormat: o, dimRoundingMode: l } = e;
@@ -3739,7 +3740,7 @@ const kp = {
  * limitations under the License.
  * =============================================================================
  */
-function xp(s, t, e, n, i) {
+function Np(s, t, e, n, i) {
   let r = s;
   s.rank === 4 && (r = A(s, [1, s.shape[0], s.shape[1], s.shape[2], s.shape[3]]));
   let a = t;
@@ -3747,7 +3748,7 @@ function xp(s, t, e, n, i) {
   const o = { x: r, dy: a }, l = { strides: n, pad: i, filterShape: e };
   return M.runKernel(el, o, l);
 }
-const vp = /* @__PURE__ */ F({ conv3DBackpropFilter_: xp });
+const vp = /* @__PURE__ */ F({ conv3DBackpropFilter_: Np });
 /**
  * @license
  * Copyright 2020 Google LLC. All Rights Reserved.
@@ -3764,8 +3765,8 @@ const vp = /* @__PURE__ */ F({ conv3DBackpropFilter_: xp });
  * limitations under the License.
  * =============================================================================
  */
-const Np = {
-  kernelName: Ni,
+const Sp = {
+  kernelName: vi,
   inputsToSave: ["x", "filter"],
   gradFunc: (s, t, e) => {
     const { dilations: n, strides: i, pad: r } = e;
@@ -3793,12 +3794,12 @@ const Np = {
  * limitations under the License.
  * =============================================================================
  */
-const Sp = {
+const Ap = {
   kernelName: nl,
   inputsToSave: ["x"],
   gradFunc: (s, t) => {
     const [e] = t;
-    return { x: () => w(pt(Pu(L(e, "float32"))), s) };
+    return { x: () => w(pt(Uu(L(e, "float32"))), s) };
   }
 };
 /**
@@ -3817,12 +3818,12 @@ const Sp = {
  * limitations under the License.
  * =============================================================================
  */
-const Ap = {
+const Cp = {
   kernelName: Si,
   inputsToSave: ["x"],
   gradFunc: (s, t) => {
     const [e] = t;
-    return { x: () => w(hh(L(e, "float32")), s) };
+    return { x: () => w(ph(L(e, "float32")), s) };
   }
 };
 /**
@@ -3841,7 +3842,7 @@ const Ap = {
  * limitations under the License.
  * =============================================================================
  */
-const Cp = {
+const Ip = {
   kernelName: Ai,
   inputsToSave: ["x"],
   gradFunc: (s, t, e) => {
@@ -3849,7 +3850,7 @@ const Cp = {
     return {
       x: () => {
         const o = Yi([i], n.rank);
-        let l = Lc(s, i, r, !a);
+        let l = Fc(s, i, r, !a);
         return o != null && (l = j(l, o)), l;
       }
     };
@@ -3871,7 +3872,7 @@ const Cp = {
  * limitations under the License.
  * =============================================================================
  */
-const Ip = {
+const Dp = {
   kernelName: Ci,
   inputsToSave: ["x", "filter"],
   gradFunc: (s, t, e) => {
@@ -3879,8 +3880,8 @@ const Ip = {
     k(Se(o), () => `Error in gradient of depthwiseConv2dNative: dilation rates greater than 1 are not yet supported. Got dilations '${o}'`);
     const [l, u] = t;
     return k(l.rank === 4, () => `Error in gradient of depthwiseConv2dNative: input must be rank 4, but got rank ${l.rank}.`), k(u.rank === 4, () => `Error in gradient of depthwiseConv2dNative: filter must be rank 4, but got rank ${u.rank}.`), k(l.shape[3] === u.shape[2], () => `Error in gradient of depthwiseConv2d: number of input channels (${l.shape[3]}) must match the inChannels dimension in filter ${u.shape[2]}.`), k(de(i, o), () => `Error in gradient of depthwiseConv2d: Either strides or dilations must be  1. Got strides ${i} and dilations '${o}'.`), ft("depthwiseConv2d", r, a), {
-      x: () => xh(l.shape, s, u, i, r, o, a),
-      filter: () => wh(l, s, u.shape, i, r, o, a)
+      x: () => Nh(l.shape, s, u, i, r, o, a),
+      filter: () => kh(l, s, u.shape, i, r, o, a)
     };
   }
 };
@@ -3900,7 +3901,7 @@ const Ip = {
  * limitations under the License.
  * =============================================================================
  */
-const Dp = {
+const zp = {
   kernelName: sl,
   inputsToSave: ["x", "filter"],
   gradFunc: (s, t, e) => {
@@ -3927,7 +3928,7 @@ const Dp = {
  * limitations under the License.
  * =============================================================================
  */
-const zp = {
+const Tp = {
   kernelName: al,
   outputsToSave: [!0],
   gradFunc: (s, t) => {
@@ -3951,7 +3952,7 @@ const zp = {
  * limitations under the License.
  * =============================================================================
  */
-const Tp = {
+const $p = {
   kernelName: Ii,
   inputsToSave: ["x"],
   gradFunc: (s, t) => {
@@ -3975,7 +3976,7 @@ const Tp = {
  * limitations under the License.
  * =============================================================================
  */
-const $p = {
+const Ep = {
   kernelName: ll,
   outputsToSave: [!0],
   gradFunc: (s, t) => {
@@ -3999,7 +4000,7 @@ const $p = {
  * limitations under the License.
  * =============================================================================
  */
-const Ep = {
+const Lp = {
   kernelName: ul,
   inputsToSave: ["input"],
   gradFunc: (s, t) => {
@@ -4023,7 +4024,7 @@ const Ep = {
  * limitations under the License.
  * =============================================================================
  */
-const Lp = {
+const Fp = {
   kernelName: cl,
   inputsToSave: ["x"],
   gradFunc: (s, t) => {
@@ -4047,7 +4048,7 @@ const Lp = {
  * limitations under the License.
  * =============================================================================
  */
-const Fp = {
+const Mp = {
   kernelName: hl,
   gradFunc: (s) => ({ x: () => Q(s) })
 };
@@ -4067,7 +4068,7 @@ const Fp = {
  * limitations under the License.
  * =============================================================================
  */
-const Mp = {
+const Op = {
   kernelName: pl,
   inputsToSave: ["a", "b"],
   gradFunc: (s, t) => {
@@ -4100,35 +4101,35 @@ const Mp = {
  * limitations under the License.
  * =============================================================================
  */
-const Op = {
+const Rp = {
   kernelName: ki,
   inputsToSave: ["x", "mean", "variance", "scale"],
   gradFunc: (s, t, e) => {
     const { varianceEpsilon: n } = e, [i, r, a, o] = t, l = o ?? tt(1), u = lt(r.shape, i.shape), c = [];
     if (r.rank === 1) {
-      for (let v = 0; v < i.shape.length - 1; ++v)
-        c.push(i.shape[v]);
+      for (let N = 0; N < i.shape.length - 1; ++N)
+        c.push(i.shape[N]);
       c.push(1);
     }
-    const h = V(i, r), p = w(s, l), f = rh($(a, tt(n))), g = w(w(w(f, f), f), tt(-0.5));
+    const h = V(i, r), p = w(s, l), f = ah($(a, tt(n))), g = w(w(w(f, f), f), tt(-0.5));
     return {
       x: () => r.rank === 1 ? A(w(w(s, Ee(A(f, [1, 1, 1, r.shape[0]]), c)), l), i.shape) : A(w(w(s, f), l), i.shape),
       mean: () => {
-        let v = w(w(f, tt(-1)), p);
-        return r.rank === 1 && (v = B(v, u)), A(v, r.shape);
+        let N = w(w(f, tt(-1)), p);
+        return r.rank === 1 && (N = B(N, u)), A(N, r.shape);
       },
       variance: () => {
-        let v = w(w(g, h), p);
-        return r.rank === 1 && (v = B(v, u)), A(v, r.shape);
+        let N = w(w(g, h), p);
+        return r.rank === 1 && (N = B(N, u)), A(N, r.shape);
       },
       scale: () => {
-        const v = w(h, f);
-        let I = w(s, v);
+        const N = w(h, f);
+        let I = w(s, N);
         return r.rank === 1 && (I = B(I, u)), A(I, r.shape);
       },
       offset: () => {
-        let v = s;
-        return r.rank === 1 && (v = B(v, u)), A(v, r.shape);
+        let N = s;
+        return r.rank === 1 && (N = B(N, u)), A(N, r.shape);
       }
     };
   }
@@ -4149,17 +4150,17 @@ const Op = {
  * limitations under the License.
  * =============================================================================
  */
-const Rp = {
+const _p = {
   kernelName: dl,
   inputsToSave: ["x", "indices"],
   gradFunc: (s, t, e) => {
     const [n, i] = t, { axis: r, batchDims: a } = e, o = he(r, n.shape)[0], l = (u, c, h) => () => {
-      const p = u.shape, f = c.size, g = p.slice(0, o), b = g.length, m = p.slice(r, p.length).slice(1), N = m.length, y = qs(0, b), C = qs(b + 1, b + 1 + N), v = Zs([
+      const p = u.shape, f = c.size, g = p.slice(0, o), b = g.length, m = p.slice(r, p.length).slice(1), v = m.length, y = qs(0, b), C = qs(b + 1, b + 1 + v), N = Zs([
         g,
         [f],
         m
-      ]), I = A(h, v), z = A(c, [f]), _ = Zs([[b], y, C]), T = j(I, _);
-      let E = fh(T, z, u.shape[o]);
+      ]), I = A(h, N), z = A(c, [f]), _ = Zs([[b], y, C]), T = j(I, _);
+      let E = mh(T, z, u.shape[o]);
       const R = ss(_);
       return E = j(E, R), E;
     };
@@ -4199,7 +4200,7 @@ function Zs(s) {
  * limitations under the License.
  * =============================================================================
  */
-const _p = {
+const Bp = {
   kernelName: fl,
   inputsToSave: ["a", "b"],
   gradFunc: (s, t) => {
@@ -4223,7 +4224,7 @@ const _p = {
  * limitations under the License.
  * =============================================================================
  */
-const Bp = {
+const Wp = {
   kernelName: ml,
   gradFunc: (s) => ({ x: () => L(s, "float32") })
 };
@@ -4243,7 +4244,7 @@ const Bp = {
  * limitations under the License.
  * =============================================================================
  */
-const Wp = {
+const Gp = {
   kernelName: gl,
   gradFunc: (s) => ({ x: () => Q(s) })
 };
@@ -4263,7 +4264,7 @@ const Wp = {
  * limitations under the License.
  * =============================================================================
  */
-const Gp = {
+const Pp = {
   kernelName: bl,
   gradFunc: (s) => ({ x: () => Q(s) })
 };
@@ -4283,7 +4284,7 @@ const Gp = {
  * limitations under the License.
  * =============================================================================
  */
-const Pp = {
+const Up = {
   kernelName: yl,
   gradFunc: (s) => ({ x: () => Q(s) })
 };
@@ -4303,12 +4304,12 @@ const Pp = {
  * limitations under the License.
  * =============================================================================
  */
-const Up = {
+const Vp = {
   kernelName: wl,
   inputsToSave: ["x"],
   gradFunc: (s, t, e) => {
     const [n] = t, { alpha: i } = e, r = Gt(n, 0);
-    return { x: () => Ht(r, s, w(s, i)) };
+    return { x: () => qt(r, s, w(s, i)) };
   }
 };
 /**
@@ -4327,7 +4328,7 @@ const Up = {
  * limitations under the License.
  * =============================================================================
  */
-const Vp = {
+const jp = {
   kernelName: Di,
   inputsToSave: ["x"],
   gradFunc: (s, t) => {
@@ -4351,7 +4352,7 @@ const Vp = {
  * limitations under the License.
  * =============================================================================
  */
-const jp = {
+const Kp = {
   kernelName: kl,
   inputsToSave: ["x"],
   gradFunc: (s, t) => {
@@ -4375,7 +4376,7 @@ const jp = {
  * limitations under the License.
  * =============================================================================
  */
-const Kp = {
+const Hp = {
   kernelName: xl,
   inputsToSave: [],
   outputsToSave: [!0],
@@ -4405,11 +4406,11 @@ const Kp = {
  * limitations under the License.
  * =============================================================================
  */
-function Hp(s, t, e, n = 5, i = 1, r = 1, a = 0.5) {
+function qp(s, t, e, n = 5, i = 1, r = 1, a = 0.5) {
   const o = { x: s, y: t, dy: e }, l = { depthRadius: n, bias: i, alpha: r, beta: a };
-  return M.runKernel(vl, o, l);
+  return M.runKernel(Nl, o, l);
 }
-const qp = F({ localResponseNormalizationBackprop_: Hp });
+const Zp = F({ localResponseNormalizationBackprop_: qp });
 /**
  * @license
  * Copyright 2020 Google LLC. All Rights Reserved.
@@ -4426,14 +4427,14 @@ const qp = F({ localResponseNormalizationBackprop_: Hp });
  * limitations under the License.
  * =============================================================================
  */
-const Zp = {
-  kernelName: Nl,
+const Jp = {
+  kernelName: vl,
   inputsToSave: ["x"],
   outputsToSave: [!0],
   gradFunc: (s, t, e) => {
     const [n, i] = t, { depthRadius: r, bias: a, alpha: o, beta: l } = e;
     return {
-      x: () => qp(n, i, s, r, a, o, l)
+      x: () => Zp(n, i, s, r, a, o, l)
     };
   }
 };
@@ -4501,12 +4502,12 @@ const Js = {
  * limitations under the License.
  * =============================================================================
  */
-const Jp = {
+const Xp = {
   kernelName: Al,
   inputsToSave: ["a", "b"],
   gradFunc: (s, t) => {
     const [e, n] = t;
-    return { a: () => w(s, L(Ue(e, n), "float32")), b: () => w(s, L(Cu(e, n), "float32")) };
+    return { a: () => w(s, L(Ke(e, n), "float32")), b: () => w(s, L(Gu(e, n), "float32")) };
   }
 };
 /**
@@ -4525,7 +4526,7 @@ const Jp = {
  * limitations under the License.
  * =============================================================================
  */
-function Xp(s, t, e, n, i, r, a) {
+function Yp(s, t, e, n, i, r, a) {
   const o = D(s, "dy", "maxPool3dGrad"), l = D(t, "input", "maxPool3dGrad"), u = D(e, "output", "maxPool3dGrad");
   let c = o, h = l, p = u, f = !1;
   l.rank === 4 && (f = !0, c = A(o, [1, o.shape[0], o.shape[1], o.shape[2], o.shape[3]]), h = A(l, [
@@ -4544,7 +4545,7 @@ function Xp(s, t, e, n, i, r, a) {
   const g = { dy: c, input: h, output: p }, b = { filterSize: n, strides: i, pad: r, dimRoundingMode: a }, m = M.runKernel(Cl, g, b);
   return f ? A(m, [m.shape[1], m.shape[2], m.shape[3], m.shape[4]]) : m;
 }
-const Yp = /* @__PURE__ */ F({ maxPool3dGrad_: Xp });
+const Qp = /* @__PURE__ */ F({ maxPool3dGrad_: Yp });
 /**
  * @license
  * Copyright 2020 Google LLC. All Rights Reserved.
@@ -4561,14 +4562,14 @@ const Yp = /* @__PURE__ */ F({ maxPool3dGrad_: Xp });
  * limitations under the License.
  * =============================================================================
  */
-const Qp = {
+const td = {
   kernelName: $i,
   inputsToSave: ["x"],
   outputsToSave: [!0],
   gradFunc: (s, t, e) => {
     const [n, i] = t, { filterSize: r, strides: a, pad: o, dimRoundingMode: l } = e;
     return {
-      x: () => Yp(s, n, i, r, a, o, l)
+      x: () => Qp(s, n, i, r, a, o, l)
     };
   }
 };
@@ -4588,13 +4589,13 @@ const Qp = {
  * limitations under the License.
  * =============================================================================
  */
-function td(s, t, e, n, i, r, a) {
+function ed(s, t, e, n, i, r, a) {
   const o = D(s, "dy", "maxPoolGrad"), l = D(t, "input", "maxPoolGrad"), u = D(e, "output", "maxPoolGrad");
   k(l.rank === o.rank, () => `Rank of input (${l.rank}) does not match rank of dy (${o.rank})`), k(o.rank === 4, () => `Error in maxPoolGrad: dy must be rank 4 but got rank ${o.rank}.`), k(l.rank === 4, () => `Error in maxPoolGrad: input must be rank 4 but got rank ${l.rank}.`), ft("maxPoolGrad", r, a);
   const c = { dy: o, input: l, output: u }, h = { filterSize: n, strides: i, pad: r, dimRoundingMode: a };
   return M.runKernel(Il, c, h);
 }
-const ed = /* @__PURE__ */ F({ maxPoolGrad_: td });
+const nd = /* @__PURE__ */ F({ maxPoolGrad_: ed });
 /**
  * @license
  * Copyright 2020 Google LLC. All Rights Reserved.
@@ -4611,14 +4612,14 @@ const ed = /* @__PURE__ */ F({ maxPoolGrad_: td });
  * limitations under the License.
  * =============================================================================
  */
-const nd = {
+const sd = {
   kernelName: Ti,
   inputsToSave: ["x"],
   outputsToSave: [!0],
   gradFunc: (s, t, e) => {
     const [n, i] = t, { filterSize: r, strides: a, pad: o } = e;
     return {
-      x: () => ed(s, n, i, r, a, o)
+      x: () => nd(s, n, i, r, a, o)
     };
   }
 };
@@ -4638,11 +4639,11 @@ const nd = {
  * limitations under the License.
  * =============================================================================
  */
-const sd = {
+const id = {
   kernelName: Dl,
   inputsToSave: ["x"],
   gradFunc: (s, t, e) => {
-    const [n] = t, { axis: i } = e, r = he(i, n.shape), o = Uu(n.shape, r)[1], l = Gi(o);
+    const [n] = t, { axis: i } = e, r = he(i, n.shape), o = Vu(n.shape, r)[1], l = Gi(o);
     return { x: () => {
       const c = n.shape.slice();
       r.forEach((f) => {
@@ -4669,7 +4670,7 @@ const sd = {
  * limitations under the License.
  * =============================================================================
  */
-const id = {
+const rd = {
   kernelName: zl,
   inputsToSave: ["x"],
   outputsToSave: [!0],
@@ -4696,12 +4697,12 @@ const id = {
  * limitations under the License.
  * =============================================================================
  */
-const rd = {
+const ad = {
   kernelName: Tl,
   inputsToSave: ["a", "b"],
   gradFunc: (s, t) => {
     const [e, n] = t;
-    return { a: () => w(s, L(Yn(e, n), "float32")), b: () => w(s, L(Gt(e, n), "float32")) };
+    return { a: () => w(s, L(es(e, n), "float32")), b: () => w(s, L(Gt(e, n), "float32")) };
   }
 };
 /**
@@ -4720,7 +4721,7 @@ const rd = {
  * limitations under the License.
  * =============================================================================
  */
-const ad = {
+const od = {
   kernelName: $l,
   inputsToSave: ["x"],
   gradFunc: (s, t, e) => {
@@ -4744,7 +4745,7 @@ const ad = {
  * limitations under the License.
  * =============================================================================
  */
-const od = {
+const ld = {
   kernelName: El,
   inputsToSave: ["a", "b"],
   gradFunc: (s, t) => {
@@ -4753,7 +4754,7 @@ const od = {
       const o = lt(e.shape, i);
       return o.length > 0 ? A(B(s, o), e.shape) : s;
     }, b: () => {
-      const o = w(s, pt(Zi(P(e, n)))), l = lt(n.shape, i);
+      const o = w(s, pt(qi(P(e, n)))), l = lt(n.shape, i);
       return l.length > 0 ? A(B(o, l), n.shape) : o;
     } };
   }
@@ -4774,7 +4775,7 @@ const od = {
  * limitations under the License.
  * =============================================================================
  */
-const ld = {
+const ud = {
   kernelName: Ll,
   inputsToSave: ["a", "b"],
   gradFunc: (s, t) => {
@@ -4804,7 +4805,7 @@ const ld = {
  * limitations under the License.
  * =============================================================================
  */
-const ud = {
+const cd = {
   kernelName: Fl,
   gradFunc: (s) => ({ x: () => pt(s) })
 };
@@ -4824,7 +4825,7 @@ const ud = {
  * limitations under the License.
  * =============================================================================
  */
-const cd = {
+const hd = {
   kernelName: Ei,
   inputsToSave: ["indices"],
   gradFunc: (s, t) => {
@@ -4848,7 +4849,7 @@ const cd = {
  * limitations under the License.
  * =============================================================================
  */
-const hd = {
+const pd = {
   kernelName: Li,
   gradFunc: (s) => ({ x: () => Q(s) })
 };
@@ -4868,12 +4869,12 @@ const hd = {
  * limitations under the License.
  * =============================================================================
  */
-const pd = {
+const dd = {
   kernelName: Ml,
   saveAllInputs: !0,
   gradFunc: (s, t, e) => {
     const { axis: n } = e;
-    return en(s, n).map((r) => () => r);
+    return nn(s, n).map((r) => () => r);
   }
 };
 /**
@@ -4916,7 +4917,7 @@ const Xs = {
  * limitations under the License.
  * =============================================================================
  */
-const dd = {
+const fd = {
   kernelName: Ol,
   inputsToSave: ["a", "b"],
   outputsToSave: [!0],
@@ -4928,7 +4929,7 @@ const dd = {
       const p = lt(r.shape, o);
       return p.length > 0 && (h = B(h, p)), A(h, r.shape);
     }, b: () => {
-      const c = Gt(r, 0), h = Ht(c, Zt(r), Q(r));
+      const c = Gt(r, 0), h = qt(c, Zt(r), Q(r));
       let p = w(s, w(i, h));
       const f = lt(a.shape, o);
       return f.length > 0 && (p = B(p, f)), A(p, a.shape);
@@ -4951,15 +4952,15 @@ const dd = {
  * limitations under the License.
  * =============================================================================
  */
-const fd = {
+const md = {
   kernelName: Rl,
   inputsToSave: ["x", "alpha"],
   gradFunc: (s, t) => {
     const [e, n] = t, i = Gt(e, 0);
     return {
-      x: () => Ht(i, s, w(s, n)),
+      x: () => qt(i, s, w(s, n)),
       alpha: () => {
-        let r = Ht(i, Q(s), w(s, e));
+        let r = qt(i, Q(s), w(s, e));
         const a = lt(n.shape, s.shape);
         return a.length > 0 && (r = B(r, a)), A(r, n.shape);
       }
@@ -4982,33 +4983,33 @@ const fd = {
  * limitations under the License.
  * =============================================================================
  */
-function md(s, t, e) {
+function gd(s, t, e) {
   const n = s.shape.slice();
   n[e] = 1;
   const i = A(t, n), r = Ps(s, e, !0, !1), a = Ps(s, e, !0, !0), o = w(r, a);
   return w(i, o);
 }
-function gd(s, t, e) {
+function bd(s, t, e) {
   const n = s.shape.length, i = n - e.length, r = Yi(e, n);
   let a = s;
   r != null && (a = j(s, r));
   const o = a.shape.slice(), u = o.splice(n - e.length, e.length).reduce((p, f) => p * f, 1);
   o.push(u);
   const c = a.reshape(o);
-  let h = md(c, t, i);
+  let h = gd(c, t, i);
   if (h = h.reshape(a.shape), r != null) {
     const p = ss(r);
     h = j(h, p);
   }
   return h;
 }
-const bd = {
+const yd = {
   kernelName: _l,
   inputsToSave: ["x"],
   gradFunc: (s, t, e) => {
     const [n] = t, { axis: i } = e;
     let r = [];
-    return i == null ? r = n.shape.map((a, o) => o) : typeof i == "number" ? r = [i] : r = i, { x: () => gd(n, s, r) };
+    return i == null ? r = n.shape.map((a, o) => o) : typeof i == "number" ? r = [i] : r = i, { x: () => bd(n, s, r) };
   }
 };
 /**
@@ -5027,7 +5028,7 @@ const bd = {
  * limitations under the License.
  * =============================================================================
  */
-const yd = {
+const wd = {
   kernelName: Bl,
   inputsToSave: ["a", "b"],
   gradFunc: (s, t) => {
@@ -5060,7 +5061,7 @@ const yd = {
  * limitations under the License.
  * =============================================================================
  */
-const wd = {
+const kd = {
   kernelName: Wl,
   inputsToSave: ["x"],
   gradFunc: (s, t) => {
@@ -5084,11 +5085,11 @@ const wd = {
  * limitations under the License.
  * =============================================================================
  */
-const kd = {
+const xd = {
   kernelName: Gl,
   inputsToSave: ["x"],
   gradFunc: (s, t) => {
-    const [e] = t, n = w(Yn(e, 6), Xn(e));
+    const [e] = t, n = w(es(e, 6), Xn(e));
     return { x: () => w(s, L(n, "float32")) };
   }
 };
@@ -5108,7 +5109,7 @@ const kd = {
  * limitations under the License.
  * =============================================================================
  */
-const xd = {
+const Nd = {
   kernelName: Pl,
   inputsToSave: ["x"],
   gradFunc: (s, t) => {
@@ -5156,7 +5157,7 @@ const vd = {
  * limitations under the License.
  * =============================================================================
  */
-const Nd = {
+const Sd = {
   kernelName: Vl,
   inputsToSave: ["images"],
   gradFunc: (s, t, e) => {
@@ -5183,7 +5184,7 @@ const Nd = {
  * limitations under the License.
  * =============================================================================
  */
-const Sd = {
+const Ad = {
   kernelName: Kl,
   inputsToSave: ["images"],
   gradFunc: (s, t, e) => {
@@ -5210,7 +5211,7 @@ const Sd = {
  * limitations under the License.
  * =============================================================================
  */
-const Ad = {
+const Cd = {
   kernelName: Oi,
   gradFunc: (s, t, e) => {
     const { dims: n } = e, i = he(n, s.shape);
@@ -5233,7 +5234,7 @@ const Ad = {
  * limitations under the License.
  * =============================================================================
  */
-const Cd = {
+const Id = {
   kernelName: ql,
   gradFunc: (s) => ({ x: () => Q(s) })
 };
@@ -5253,7 +5254,7 @@ const Cd = {
  * limitations under the License.
  * =============================================================================
  */
-const Id = {
+const Dd = {
   kernelName: Ri,
   inputsToSave: ["x"],
   gradFunc: (s, t) => {
@@ -5277,7 +5278,7 @@ const Id = {
  * limitations under the License.
  * =============================================================================
  */
-const Dd = {
+const zd = {
   kernelName: Zl,
   inputsToSave: ["condition"],
   gradFunc: (s, t) => {
@@ -5287,7 +5288,7 @@ const Dd = {
       // when backprop supports it.
       condition: () => L(Q(e), "float32"),
       t: () => w(s, L(e, s.dtype)),
-      e: () => w(s, L(jc(e), s.dtype))
+      e: () => w(s, L(Kc(e), s.dtype))
     };
   }
 };
@@ -5307,15 +5308,15 @@ const Dd = {
  * limitations under the License.
  * =============================================================================
  */
-const zd = {
+const Td = {
   kernelName: _i,
   inputsToSave: ["x"],
   gradFunc: (s, t) => {
     const [e] = t;
     return {
       x: () => {
-        const n = Gt(e, tt(0)), i = tt(Ah), r = tt(Ch), a = w(s, r), o = w(w(s, i), Jt(L(e, "float32")));
-        return Ht(n, a, o);
+        const n = Gt(e, tt(0)), i = tt(Ch), r = tt(Ih), a = w(s, r), o = w(w(s, i), Jt(L(e, "float32")));
+        return qt(n, a, o);
       }
     };
   }
@@ -5336,7 +5337,7 @@ const zd = {
  * limitations under the License.
  * =============================================================================
  */
-const Td = {
+const $d = {
   kernelName: Jl,
   outputsToSave: [!0],
   gradFunc: (s, t) => {
@@ -5360,7 +5361,7 @@ const Td = {
  * limitations under the License.
  * =============================================================================
  */
-const $d = {
+const Ed = {
   kernelName: Xl,
   gradFunc: (s) => ({ x: () => Q(s) })
 };
@@ -5380,7 +5381,7 @@ const $d = {
  * limitations under the License.
  * =============================================================================
  */
-const Ed = {
+const Ld = {
   kernelName: Yl,
   inputsToSave: ["x"],
   gradFunc: (s, t) => {
@@ -5404,12 +5405,12 @@ const Ed = {
  * limitations under the License.
  * =============================================================================
  */
-const Ld = {
+const Fd = {
   kernelName: Bi,
   inputsToSave: ["x"],
   gradFunc: (s, t) => {
     const [e] = t;
-    return { x: () => w(Tc(L(e, "float32")), s) };
+    return { x: () => w($c(L(e, "float32")), s) };
   }
 };
 /**
@@ -5428,11 +5429,11 @@ const Ld = {
  * limitations under the License.
  * =============================================================================
  */
-const Fd = {
+const Md = {
   kernelName: Ql,
   inputsToSave: ["x"],
   gradFunc: (s, t, e) => {
-    const [n] = t, { begin: i, size: r } = e, a = n.shape, [o, l] = ju(n, i, r), u = [];
+    const [n] = t, { begin: i, size: r } = e, a = n.shape, [o, l] = Ku(n, i, r), u = [];
     for (let c = 0; c < s.rank; c++)
       u.push([o[c], a[c] - o[c] - l[c]]);
     return { x: () => sr(s, u) };
@@ -5454,7 +5455,7 @@ const Fd = {
  * limitations under the License.
  * =============================================================================
  */
-const Md = {
+const Od = {
   kernelName: tu,
   outputsToSave: [!0],
   gradFunc: (s, t, e) => {
@@ -5480,12 +5481,12 @@ const Md = {
  * limitations under the License.
  * =============================================================================
  */
-const Od = {
+const Rd = {
   kernelName: zi,
   inputsToSave: ["x"],
   gradFunc: (s, t) => {
     const [e] = t;
-    return { x: () => w(s, Qn(e)) };
+    return { x: () => w(s, Yn(e)) };
   }
 };
 /**
@@ -5508,7 +5509,7 @@ const Ys = {
   kernelName: Mi,
   gradFunc: (s, t, e) => {
     const { blockShape: n, paddings: i } = e;
-    return { x: () => uc(s, n, i) };
+    return { x: () => cc(s, n, i) };
   }
 };
 /**
@@ -5550,7 +5551,7 @@ const Qs = {
  * limitations under the License.
  * =============================================================================
  */
-const Rd = {
+const _d = {
   kernelName: nu,
   inputsToSave: ["x"],
   gradFunc: (s, t) => {
@@ -5574,7 +5575,7 @@ const Rd = {
  * limitations under the License.
  * =============================================================================
  */
-const _d = {
+const Bd = {
   kernelName: su,
   inputsToSave: ["x"],
   gradFunc: (s, t) => {
@@ -5598,7 +5599,7 @@ const _d = {
  * limitations under the License.
  * =============================================================================
  */
-const Bd = {
+const Wd = {
   kernelName: iu,
   inputsToSave: ["a", "b"],
   gradFunc: (s, t) => {
@@ -5622,7 +5623,7 @@ const Bd = {
  * limitations under the License.
  * =============================================================================
  */
-const Wd = {
+const Gd = {
   kernelName: ru,
   gradFunc: (s) => ({ x: () => Q(s) })
 };
@@ -5642,7 +5643,7 @@ const Wd = {
  * limitations under the License.
  * =============================================================================
  */
-const Gd = {
+const Pd = {
   kernelName: au,
   inputsToSave: ["a", "b"],
   gradFunc: (s, t) => {
@@ -5674,7 +5675,7 @@ const Gd = {
  * limitations under the License.
  * =============================================================================
  */
-const Pd = {
+const Ud = {
   kernelName: ou,
   inputsToSave: ["x"],
   gradFunc: (s, t, e) => {
@@ -5702,7 +5703,7 @@ const Pd = {
  * limitations under the License.
  * =============================================================================
  */
-const Ud = {
+const Vd = {
   kernelName: lu,
   inputsToSave: ["x"],
   gradFunc: (s, t) => {
@@ -5726,7 +5727,7 @@ const Ud = {
  * limitations under the License.
  * =============================================================================
  */
-const Vd = {
+const jd = {
   kernelName: yi,
   outputsToSave: [!0],
   gradFunc: (s, t) => {
@@ -5750,7 +5751,7 @@ const Vd = {
  * limitations under the License.
  * =============================================================================
  */
-const jd = {
+const Kd = {
   kernelName: uu,
   inputsToSave: ["x"],
   gradFunc: (s, t, e) => {
@@ -5805,7 +5806,7 @@ const jd = {
  * limitations under the License.
  * =============================================================================
  */
-const Kd = {
+const Hd = {
   kernelName: cu,
   gradFunc: (s, t, e) => {
     const n = e, { perm: i } = n, r = ss(i);
@@ -5828,7 +5829,7 @@ const Kd = {
  * limitations under the License.
  * =============================================================================
  */
-const Hd = {
+const qd = {
   kernelName: hu,
   gradFunc: (s, t, e) => {
     const n = e, { axis: i } = n;
@@ -5851,23 +5852,23 @@ const Hd = {
  * limitations under the License.
  * =============================================================================
  */
-const qd = {
+const Zd = {
   kernelName: Wi,
   inputsToSave: ["segmentIds"],
   gradFunc: (s, t) => {
     const [e] = t;
-    return { x: () => Zd(s, e) };
+    return { x: () => Jd(s, e) };
   }
 };
-function Zd(s, t) {
+function Jd(s, t) {
   const e = Ie(t, Q(t)), n = Qi(s, e);
-  let i = Ue(t, tt(0, "int32"));
+  let i = Ke(t, tt(0, "int32"));
   const r = n.rank - i.rank;
   for (let o = 0; o < r; ++o)
-    i = ue(i, o + 1);
-  i = Pe(i, pe(n.shape, "bool"));
+    i = ce(i, o + 1);
+  i = je(i, pe(n.shape, "bool"));
   const a = Q(n);
-  return Ht(i, n, a);
+  return qt(i, n, a);
 }
 /**
  * @license
@@ -5885,7 +5886,7 @@ function Zd(s, t) {
  * limitations under the License.
  * =============================================================================
  */
-const Jd = {
+const Xd = {
   kernelName: pu,
   gradFunc: (s) => ({ x: () => Q(s) })
 };
@@ -5905,9 +5906,8 @@ const Jd = {
  * limitations under the License.
  * =============================================================================
  */
-const Xd = [
+const Yd = [
   fr,
-  qh,
   Zh,
   Jh,
   Xh,
@@ -5918,8 +5918,8 @@ const Xd = [
   np,
   sp,
   ip,
-  op,
-  cp,
+  rp,
+  lp,
   hp,
   pp,
   dp,
@@ -5928,23 +5928,23 @@ const Xd = [
   gp,
   bp,
   yp,
-  kp,
   wp,
-  Np,
+  xp,
+  kp,
   Sp,
   Ap,
   Cp,
   Ip,
   Dp,
-  yd,
   zp,
+  wd,
   Tp,
   $p,
   Ep,
   Lp,
-  Mp,
   Fp,
   Op,
+  Mp,
   Rp,
   _p,
   Bp,
@@ -5955,12 +5955,12 @@ const Xd = [
   Vp,
   jp,
   Kp,
-  Zp,
+  Hp,
+  Jp,
   Js,
   Js,
-  Jp,
-  Qp,
-  nd,
+  Xp,
+  td,
   sd,
   id,
   rd,
@@ -5971,16 +5971,16 @@ const Xd = [
   cd,
   hd,
   pd,
+  dd,
   Xs,
   Xs,
-  dd,
   fd,
-  bd,
-  wd,
+  md,
+  yd,
   kd,
   xd,
-  vd,
   Nd,
+  vd,
   Sd,
   Ad,
   Cd,
@@ -5994,14 +5994,14 @@ const Xd = [
   Fd,
   Md,
   Od,
+  Rd,
   Ys,
   Ys,
   Qs,
   Qs,
-  Rd,
-  Bd,
   _d,
   Wd,
+  Bd,
   Gd,
   Pd,
   Ud,
@@ -6010,9 +6010,10 @@ const Xd = [
   Kd,
   Hd,
   qd,
-  Jd
+  Zd,
+  Xd
 ];
-for (const s of Xd)
+for (const s of Yd)
   du(s);
 /**
  * @license
@@ -6062,7 +6063,7 @@ br.className = "UnitNorm";
 S(br);
 class yr extends qe {
   apply(t) {
-    return Ve(t);
+    return Pe(t);
   }
 }
 yr.className = "NonNeg";
@@ -6117,7 +6118,7 @@ function rt(s) {
  * https://opensource.org/licenses/MIT.
  * =============================================================================
  */
-function Yd(s) {
+function Qd(s) {
   return new ps(s);
 }
 /**
@@ -6167,7 +6168,7 @@ var ni;
 (function(s) {
   s[s.SILENT = 0] = "SILENT", s[s.VERBOSE = 1] = "VERBOSE";
 })(ni || (ni = {}));
-const Qd = 125;
+const tf = 125;
 class Me {
   constructor() {
     this.validationData = null;
@@ -6197,7 +6198,7 @@ class Me {
   setModel(t) {
   }
 }
-class tf {
+class ef {
   // TODO(cais): When the need arises, uncomment the following lines and
   // implement the queue for time values.
   // private deltaTBatch: number;
@@ -6282,7 +6283,7 @@ class tf {
       await e.onTrainEnd(t);
   }
 }
-class ef extends Me {
+class nf extends Me {
   constructor() {
     super();
   }
@@ -6314,7 +6315,7 @@ class ef extends Me {
         }));
   }
 }
-class nf extends Me {
+class sf extends Me {
   async onTrainBegin(t) {
     this.epoch = [], this.history = {};
   }
@@ -6341,11 +6342,11 @@ class nf extends Me {
       this.history[e[r]][n[r]].dispose(), this.history[e[r]][n[r]] = i[r][0];
   }
 }
-class sf extends Me {
+class rf extends Me {
   constructor(t, e) {
-    if (super(), this.currentEpoch = 0, this.nowFunc = t.nowFunc, this.nextFrameFunc = t.nextFrameFunc || Sh, this.yieldEvery = e || "auto", this.yieldEvery === "auto" && (this.yieldEvery = Qd), this.yieldEvery === "never" && t.onYield != null)
+    if (super(), this.currentEpoch = 0, this.nowFunc = t.nowFunc, this.nextFrameFunc = t.nextFrameFunc || Ah, this.yieldEvery = e || "auto", this.yieldEvery === "auto" && (this.yieldEvery = tf), this.yieldEvery === "never" && t.onYield != null)
       throw new Error("yieldEvery is `never` but you provided an `onYield` callback. Either change `yieldEvery` or remove the callback");
-    Fs(this.yieldEvery) && (this.maybeWait = Iu(this.maybeWait.bind(this), this.yieldEvery, this.nowFunc)), this.trainBegin = t.onTrainBegin, this.trainEnd = t.onTrainEnd, this.epochBegin = t.onEpochBegin, this.epochEnd = t.onEpochEnd, this.batchBegin = t.onBatchBegin, this.batchEnd = t.onBatchEnd, this.yield = t.onYield;
+    Fs(this.yieldEvery) && (this.maybeWait = Su(this.maybeWait.bind(this), this.yieldEvery, this.nowFunc)), this.trainBegin = t.onTrainBegin, this.trainEnd = t.onTrainEnd, this.epochBegin = t.onEpochBegin, this.epochEnd = t.onEpochEnd, this.batchBegin = t.onBatchBegin, this.batchEnd = t.onBatchEnd, this.yield = t.onYield;
   }
   async maybeWait(t, e, n) {
     const i = [];
@@ -6373,7 +6374,7 @@ class sf extends Me {
   }
 }
 function xr(s, t) {
-  return s == null && (s = {}), s instanceof Me ? [s] : Array.isArray(s) && s[0] instanceof Me ? s : K(s).map((n) => new sf(n, t));
+  return s == null && (s = {}), s instanceof Me ? [s] : Array.isArray(s) && s[0] instanceof Me ? s : K(s).map((n) => new rf(n, t));
 }
 class yt {
   /**
@@ -6427,13 +6428,13 @@ class yt {
   }
 }
 yt.constructors = {};
-function vr(s, t, e, n, i, r, a, o, l) {
-  const u = new nf(), c = [
-    new ef(),
+function Nr(s, t, e, n, i, r, a, o, l) {
+  const u = new sf(), c = [
+    new nf(),
     ...yt.createCallbacks(t)
   ];
   s != null && c.push(...s), c.push(u);
-  const h = new tf(c);
+  const h = new ef(c);
   return h.setParams({
     epochs: e,
     initialEpoch: n,
@@ -6469,47 +6470,47 @@ function Wt(s, t = {}, e = !1) {
 function pn(s, t) {
   return x(() => {
     s.dtype !== "float32" && (s = L(s, "float32"));
-    const e = B(je(s), t, !0), n = fu(e.shape, nt()), i = ee(Ie(e, n));
+    const e = B(Ue(s), t, !0), n = fu(e.shape, nt()), i = ee(Ie(e, n));
     return P(s, i);
   });
 }
-function Nn(s, t) {
-  return x(() => at(je(V(t, s)), -1));
+function vn(s, t) {
+  return x(() => at(Ue(V(t, s)), -1));
 }
 function xs(s, t) {
   return x(() => at(Fe(V(t, s)), -1));
 }
-function vs(s, t) {
+function Ns(s, t) {
   return x(() => {
     const e = V(s, t), n = Ct(Fe(s), nt(), Number.MAX_VALUE), i = Fe(P(e, n));
     return w(100, at(i, -1));
   });
 }
-function rf(s, t) {
+function af(s, t) {
   return x(() => {
     const e = Ct(t, nt(), Number.MAX_VALUE), n = Zt($(1, e)), i = Ct(s, nt(), Number.MAX_VALUE), r = Zt($(1, i));
-    return at(je(V(n, r)), -1);
+    return at(Ue(V(n, r)), -1);
   });
 }
-function af(s, t) {
+function of(s, t) {
   return x(() => {
     const e = Ie(0, V(1, w(s, t)));
-    return at(je(e), -1);
+    return at(Ue(e), -1);
   });
 }
-function of(s, t) {
+function lf(s, t) {
   return x(() => {
     const e = Ie(0, V(1, w(s, t)));
     return at(e, -1);
   });
 }
-function lf(s, t) {
+function uf(s, t) {
   return x(() => {
-    const e = B(w(s, t), -1), n = Ne(w(V(1, s), t), -1);
+    const e = B(w(s, t), -1), n = ve(w(V(1, s), t), -1);
     return Ie(0, $(1, V(n, e)));
   });
 }
-function uf(s, t) {
+function cf(s, t) {
   return x(() => {
     const e = Math.log(2), n = V(t, s), i = V($(n, us(w(-2, n))), e);
     return at(i, -1);
@@ -6528,59 +6529,59 @@ function Oe(s, t, e = !1) {
 }
 function dn(s, t, e = !1) {
   return x(() => {
-    const n = L(Zi(Du(s)), "int32");
+    const n = L(qi(Au(s)), "int32");
     t = Ct(t, nt(), 1 - nt());
-    const i = t.shape, r = A(Yc(n, i[i.length - 1]), i);
+    const i = t.shape, r = A(Qc(n, i[i.length - 1]), i);
     return Oe(r, t, e);
   });
 }
-function cf(s, t) {
+function hf(s, t) {
   if (!Ft(s.shape, t.shape))
     throw new d(`logits and labels must have the same shape, but got shapes ${JSON.stringify(s.shape)} and ${JSON.stringify(t.shape)}`);
   return x(() => {
-    const e = Ve(t), n = pt(Fe(t));
-    return $(V(e, w(t, s)), Wc(Jt(n)));
+    const e = Pe(t), n = pt(Fe(t));
+    return $(V(e, w(t, s)), Gc(Jt(n)));
   });
 }
 function Sn(s, t) {
   return x(() => {
     let e;
-    return e = Ct(t, nt(), 1 - nt()), e = Zt(P(e, V(1, e))), at(cf(s, e), -1);
+    return e = Ct(t, nt(), 1 - nt()), e = Zt(P(e, V(1, e))), at(hf(s, e), -1);
   });
 }
-function hf(s, t) {
+function pf(s, t) {
   return x(() => {
     const e = Ct(s, nt(), 1), n = Ct(t, nt(), 1);
     return B(w(s, Zt(P(e, n))), -1);
   });
 }
-function pf(s, t) {
+function df(s, t) {
   return x(() => {
     const e = Zt($(nt(), t));
     return at(V(t, w(s, e)), -1);
   });
 }
-function Nr(s, t) {
+function vr(s, t) {
   return x(() => {
     const e = pn(s, -1), n = pn(t, -1), i = w(e, n);
     return pt(B(i, -1));
   });
 }
 const fn = {
-  meanSquaredError: Nn,
+  meanSquaredError: vn,
   meanAbsoluteError: xs,
-  meanAbsolutePercentageError: vs,
-  meanSquaredLogarithmicError: rf,
-  squaredHinge: af,
-  hinge: of,
-  categoricalHinge: lf,
-  logcosh: uf,
+  meanAbsolutePercentageError: Ns,
+  meanSquaredLogarithmicError: af,
+  squaredHinge: of,
+  hinge: lf,
+  categoricalHinge: uf,
+  logcosh: cf,
   categoricalCrossentropy: Oe,
   sparseCategoricalCrossentropy: dn,
   binaryCrossentropy: Sn,
-  kullbackLeiblerDivergence: hf,
-  poisson: pf,
-  cosineProximity: Nr
+  kullbackLeiblerDivergence: pf,
+  poisson: df,
+  cosineProximity: vr
 };
 function $n(s) {
   if (typeof s == "string") {
@@ -6609,39 +6610,39 @@ function Sr(s, t) {
 function Ar(s, t) {
   return x(() => Lt(Xt(sn(s, -1), sn(t, -1)), "float32"));
 }
-function df(s, t) {
-  return x(() => L(B(Pe(Xt(s, 1), Xt(t, 1))), "float32"));
-}
 function ff(s, t) {
-  return x(() => L(B(Pe(Xt(s, 0), Xt(t, 1))), "float32"));
+  return x(() => L(B(je(Xt(s, 1), Xt(t, 1))), "float32"));
 }
 function mf(s, t) {
+  return x(() => L(B(je(Xt(s, 0), Xt(t, 1))), "float32"));
+}
+function gf(s, t) {
   return x(() => {
-    const e = df(s, t), n = ff(s, t), i = $(e, n);
-    return L(Ht(Gt(i, 0), P(e, i), 0), "float32");
+    const e = ff(s, t), n = mf(s, t), i = $(e, n);
+    return L(qt(Gt(i, 0), P(e, i), 0), "float32");
   });
 }
-function gf(s, t) {
+function bf(s, t) {
   return Sn(s, t);
 }
-function bf(s, t) {
-  return s.rank === t.rank && (s = ts(s, [s.rank - 1])), t = sn(t, -1), t.dtype !== s.dtype && (t = L(t, s.dtype)), L(Xt(s, t), "float32");
+function yf(s, t) {
+  return s.rank === t.rank && (s = ns(s, [s.rank - 1])), t = sn(t, -1), t.dtype !== s.dtype && (t = L(t, s.dtype)), L(Xt(s, t), "float32");
 }
-const yf = Nn, wf = Nn, kf = xs, xf = xs, vf = vs, Nf = vs, Cr = Oe, Sf = Nr, Ir = dn, mn = {
+const wf = vn, kf = vn, xf = xs, Nf = xs, vf = Ns, Sf = Ns, Cr = Oe, Af = vr, Ir = dn, mn = {
   binaryAccuracy: Sr,
   categoricalAccuracy: Ar,
-  precision: mf,
+  precision: gf,
   categoricalCrossentropy: Cr,
   sparseCategoricalCrossentropy: Ir,
-  mse: yf,
-  MSE: wf,
-  mae: kf,
-  MAE: xf,
+  mse: wf,
+  MSE: kf,
+  mae: xf,
+  MAE: Nf,
   mape: vf,
-  MAPE: Nf,
-  cosine: Sf
+  MAPE: Sf,
+  cosine: Af
 };
-function Af(s) {
+function Cf(s) {
   if (typeof s == "string" && s in mn)
     return mn[s];
   if (typeof s != "string" && s != null)
@@ -6677,7 +6678,7 @@ function tn(s) {
  * https://opensource.org/licenses/MIT.
  * =============================================================================
  */
-function Cf(s) {
+function If(s) {
   const t = {
     Adagrad: () => ge.adagrad(0.01),
     Adadelta: () => ge.adadelta(1, 0.95, nt()),
@@ -6739,8 +6740,8 @@ function Pn(s) {
  * https://opensource.org/licenses/MIT.
  * =============================================================================
  */
-function If(s, t, e, n = console.log) {
-  const i = zf(s), r = ["Layer (type)", "Input Shape", "Output shape", "Param #"];
+function Df(s, t, e, n = console.log) {
+  const i = Tf(s), r = ["Layer (type)", "Input Shape", "Output shape", "Param #"];
   i ? (t = t || 90, e = e || [0.32, 0.61, 0.89, 1]) : (t = t || 115, e = e || [0.24, 0.48, 0.7, 0.8, 1]), e[e.length - 1] <= 1 && (e = e.map((c) => Math.floor(t * c)));
   let a;
   if (!i) {
@@ -6751,16 +6752,16 @@ function If(s, t, e, n = console.log) {
   n("_".repeat(t)), gn(r, e, n), n("=".repeat(t));
   const o = s.layers;
   for (let c = 0; c < o.length; ++c)
-    i ? Tf(o[c], e, n) : $f(o[c], e, a, n), n((c === o.length - 1 ? "=" : "_").repeat(t));
+    i ? $f(o[c], e, n) : Ef(o[c], e, a, n), n((c === o.length - 1 ? "=" : "_").repeat(t));
   s.checkTrainableWeightsConsistency();
-  const l = Df(s), u = un(s.nonTrainableWeights);
+  const l = zf(s), u = un(s.nonTrainableWeights);
   n(`Total params: ${l + u}`), n(`Trainable params: ${l}`), n(`Non-trainable params: ${u}`), n("_".repeat(t));
 }
-function Df(s) {
+function zf(s) {
   let t;
   return s.collectedTrainableWeights != null ? t = un(s.collectedTrainableWeights) : t = un(s.trainableWeights), t;
 }
-function zf(s) {
+function Tf(s) {
   let t = !0;
   const e = [], n = [];
   for (const i in s.nodesByDepth)
@@ -6793,7 +6794,7 @@ function gn(s, t, e = console.log) {
     i > 0 && (n = n.slice(0, n.length - 1) + " "), n += s[i], n = n.slice(0, t[i]), n += " ".repeat(t[i] - n.length);
   e(n);
 }
-function Tf(s, t, e) {
+function $f(s, t, e) {
   let n, i;
   try {
     i = s.inboundNodes.map((l) => JSON.stringify(l.inputShapes)).join(",");
@@ -6813,7 +6814,7 @@ function Tf(s, t, e) {
   ];
   gn(o, t, e);
 }
-function $f(s, t, e, n) {
+function Ef(s, t, e, n) {
   let i, r;
   try {
     r = s.inboundNodes.map((h) => JSON.stringify(h.inputShapes)).join(",");
@@ -6917,14 +6918,14 @@ const zr = "4.22.0";
  * https://opensource.org/licenses/MIT.
  * =============================================================================
  */
-const Ef = (s) => {
+const Lf = (s) => {
   const t = Object.keys(s);
   if (t.length === 0)
     return !1;
   const e = t[0].split("/");
   return !isNaN(parseInt(e[e.length - 1], 10));
 };
-class Nt extends W {
+class vt extends W {
   constructor(t) {
     if (super({}), this.containerNodes = /* @__PURE__ */ new Set(), this.name = t.name, this.name == null) {
       const y = this.getClassName().toLowerCase();
@@ -6934,12 +6935,12 @@ class Nt extends W {
       throw new d(`The list of inputs passed to the model is redundant. All inputs should only appear once. Found: ${this.inputs.map((y) => y.name)}`);
     jt(this.outputs).length !== this.outputs.length && console.warn(`The list of outputs passed to the model is redundant. All outputs should only appear once. Found: ${this.outputs.map((y) => y.name)}`), this.inputLayers = [], this.inputLayersNodeIndices = [], this.inputLayersTensorIndices = [], this.outputLayers = [], this.outputLayersNodeIndices = [], this.outputLayersTensorIndices = [], this.layers = [], this.internalContainerRefs = [];
     for (const y of this.outputs) {
-      const C = y.sourceLayer, v = y.nodeIndex, I = y.tensorIndex;
-      this.outputLayers.push(C), this.outputLayersNodeIndices.push(v), this.outputLayersTensorIndices.push(I);
+      const C = y.sourceLayer, N = y.nodeIndex, I = y.tensorIndex;
+      this.outputLayers.push(C), this.outputLayersNodeIndices.push(N), this.outputLayersTensorIndices.push(I);
     }
     for (const y of this.inputs) {
-      const C = y.sourceLayer, v = y.nodeIndex, I = y.tensorIndex;
-      Ut(v === 0, "input layer has >1 nodes"), Ut(I === 0, "input layer has >1 tensors"), this.inputLayers.push(C), this.inputLayersNodeIndices.push(v), this.inputLayersTensorIndices.push(I);
+      const C = y.sourceLayer, N = y.nodeIndex, I = y.tensorIndex;
+      Ut(N === 0, "input layer has >1 nodes"), Ut(I === 0, "input layer has >1 tensors"), this.inputLayers.push(C), this.inputLayersNodeIndices.push(N), this.inputLayersTensorIndices.push(I);
     }
     this.inputNames = [], this.outputNames = [], this.feedInputShapes = [], this.feedInputNames = [], this.feedOutputNames = [];
     for (let y = 0; y < this.inputLayers.length; y++) {
@@ -6951,21 +6952,21 @@ class Nt extends W {
     for (const y of this.outputLayers)
       this.outputNames.push(y.name);
     this.internalInputShapes = this.inputs.map((y) => y.shape), this.internalOutputShapes = this.outputs.map((y) => y.shape);
-    const e = {}, n = {}, i = {}, r = {}, a = {}, o = [], l = (y, C, v, I, z, _) => {
+    const e = {}, n = {}, i = {}, r = {}, a = {}, o = [], l = (y, C, N, I, z, _) => {
       (I == null || z == null || _ == null) && (I = y.sourceLayer, z = y.nodeIndex, _ = y.tensorIndex);
       const T = I.inboundNodes[z];
-      if (v.indexOf(T) !== -1)
+      if (N.indexOf(T) !== -1)
         throw new Et(`The tensor ${y.name} at layer "${I.name}" is part of a cycle.`);
       if (C.indexOf(T) !== -1)
         return;
-      this.containerNodes.add(Nt.nodeKey(I, z)), I.id in a || (a[I.id] = Object.keys(a).length), v.indexOf(T) === -1 && v.push(T);
+      this.containerNodes.add(vt.nodeKey(I, z)), I.id in a || (a[I.id] = Object.keys(a).length), N.indexOf(T) === -1 && N.push(T);
       const E = T.inboundLayers.length;
       for (let R = 0; R < E; R++) {
         const q = T.inputTensors[R], bt = T.inboundLayers[R], ie = T.nodeIndices[R], re = T.tensorIndices[R];
-        l(q, C, v, bt, ie, re);
+        l(q, C, N, bt, ie, re);
       }
-      for (C.push(T); v.indexOf(T) >= 0; )
-        v.splice(v.indexOf(T), 1);
+      for (C.push(T); N.indexOf(T) >= 0; )
+        N.splice(N.indexOf(T), 1);
       o.push(T);
     }, u = [], c = [];
     for (const y of this.outputs)
@@ -6974,8 +6975,8 @@ class Nt extends W {
     for (const y of h) {
       n[y.id] = y, y.id in e || (e[y.id] = 0);
       let C = e[y.id];
-      const v = i[y.outboundLayer.id] == null ? 0 : i[y.outboundLayer.id];
-      C = Math.max(C, v), i[y.outboundLayer.id] = C, r[y.outboundLayer.id] = y.outboundLayer, e[y.id] = C;
+      const N = i[y.outboundLayer.id] == null ? 0 : i[y.outboundLayer.id];
+      C = Math.max(C, N), i[y.outboundLayer.id] = C, r[y.outboundLayer.id] = y.outboundLayer, e[y.id] = C;
       for (let I = 0; I < y.inboundLayers.length; I++) {
         const z = y.inboundLayers[I], _ = y.nodeIndices[I], T = z.inboundNodes[_], E = e[T.id] == null ? 0 : e[T.id];
         e[T.id] = Math.max(C + 1, E), n[T.id] = T;
@@ -6995,35 +6996,35 @@ class Nt extends W {
     this.layers = [];
     for (const y of g) {
       const C = f[y];
-      C.sort((v, I) => {
-        const z = a[v.id], _ = a[I.id];
+      C.sort((N, I) => {
+        const z = a[N.id], _ = a[I.id];
         return z < _ ? -1 : z > _ ? 1 : 0;
       });
-      for (const v of C)
-        v instanceof Nt && this.internalContainerRefs.push(v), this.layers.push(v);
+      for (const N of C)
+        N instanceof vt && this.internalContainerRefs.push(N), this.layers.push(N);
     }
     this.layersByDepth = f, g = Object.keys(p).map((y) => parseInt(y, 10)).sort(Xe);
     const b = this.inputs.slice(), m = [];
     for (const y of g)
       for (const C of p[y]) {
-        const v = C.outboundLayer;
-        if (v != null) {
+        const N = C.outboundLayer;
+        if (N != null) {
           for (const I of C.inputTensors)
             if (b.indexOf(I) === -1)
-              throw new Et(`Graph disconnected: cannot obtain value for tensor ${I} at layer "${v.name}". The following previous layers were accessed without issue: ${m}`);
+              throw new Et(`Graph disconnected: cannot obtain value for tensor ${I} at layer "${N.name}". The following previous layers were accessed without issue: ${m}`);
           for (const I of C.outputTensors)
             b.push(I);
-          m.push(v.name);
+          m.push(N.name);
         }
       }
     this.nodesByDepth = p;
-    const N = this.layers.map((y) => y.name);
-    for (const y of N) {
-      const C = N.filter((v) => v === y).length;
+    const v = this.layers.map((y) => y.name);
+    for (const y of v) {
+      const C = v.filter((N) => N === y).length;
       if (C !== 1)
-        throw new Et(`The name "${y}" is used ${C} times in the model. All layer names should be unique. Layer names: ` + JSON.stringify(N));
+        throw new Et(`The name "${y}" is used ${C} times in the model. All layer names should be unique. Layer names: ` + JSON.stringify(v));
     }
-    this.outboundNodes = [], this.inboundNodes = [], new vn({
+    this.outboundNodes = [], this.inboundNodes = [], new Nn({
       outboundLayer: this,
       inboundLayers: [],
       nodeIndices: [],
@@ -7128,7 +7129,7 @@ class Nt extends W {
   loadWeights(t, e = !0) {
     const n = {};
     let i = 0;
-    const r = Ef(t);
+    const r = Lf(t);
     r && this.parseWeights(t);
     for (const o of this.layers)
       for (const [l, u] of o.weights.entries()) {
@@ -7224,7 +7225,7 @@ class Nt extends W {
     return x(() => {
       t = K(t);
       let n;
-      return e == null ? n = ce(null, t.length) : n = K(e), this.runInternalGraph(t, n)[1];
+      return e == null ? n = ue(null, t.length) : n = K(e), this.runInternalGraph(t, n)[1];
     });
   }
   /**
@@ -7255,8 +7256,8 @@ class Nt extends W {
             continue;
           const h = [];
           for (let b = 0; b < u.inboundLayers.length; b++) {
-            const m = u.inboundLayers[b], N = u.nodeIndices[b], y = u.tensorIndices[b], C = `${m.name}_${N}_${y}`, v = n[C];
-            h.push(v);
+            const m = u.inboundLayers[b], v = u.nodeIndices[b], y = u.tensorIndices[b], C = `${m.name}_${v}_${y}`, N = n[C];
+            h.push(N);
           }
           const p = c.computeOutputShape(ht(h)), f = ln(p), g = c.inboundNodes.indexOf(u);
           for (let b = 0; b < f.length; b++) {
@@ -7287,7 +7288,7 @@ class Nt extends W {
    * @return Three lists: outputTensors, outputMasks, outputShapes
    */
   runInternalGraph(t, e) {
-    e == null && (e = ce(null, t.length));
+    e == null && (e = ue(null, t.length));
     const n = {};
     for (let l = 0; l < this.inputs.length; ++l) {
       const u = this.inputs[l], c = t[l], h = e[l];
@@ -7301,16 +7302,16 @@ class Nt extends W {
         for (const b of p)
           b.id in n && g.push(n[b.id]);
         if (g.length === p.length) {
-          let b = {}, m, N, y, C;
+          let b = {}, m, v, y, C;
           if (c.callArgs != null && (b = c.callArgs), g.length === 1) {
-            const [v, I] = g[0];
-            b.mask == null && (b.mask = I), y = K(h.call(v, b)), C = K(h.computeMask(v, I)), m = [v], N = [I];
+            const [N, I] = g[0];
+            b.mask == null && (b.mask = I), y = K(h.call(N, b)), C = K(h.computeMask(N, I)), m = [N], v = [I];
           } else
-            m = g.map((v) => v[0]), N = g.map((v) => v[1]), b.mask == null && (b.mask = N), y = K(h.call(m, b)), C = K(h.computeMask(m, N));
+            m = g.map((N) => N[0]), v = g.map((N) => N[1]), b.mask == null && (b.mask = v), y = K(h.call(m, b)), C = K(h.computeMask(m, v));
           if (h.activityRegularizer)
             throw new G("LayersModel invocation with concrete Tensor value(s) in the presence of activity regularizer(s) is not supported yet.");
-          for (let v = 0; v < f.length; ++v) {
-            const I = f[v], z = y[v], _ = C[v];
+          for (let N = 0; N < f.length; ++N) {
+            const I = f[N], z = y[N], _ = C[N];
             n[I.id] = [z, _];
           }
         }
@@ -7336,9 +7337,9 @@ class Nt extends W {
     const e = {};
     let n;
     for (const i of this.layers) {
-      n = i instanceof Nt ? 1 : 0;
+      n = i instanceof vt ? 1 : 0;
       for (let r = 0; r < i.inboundNodes.length; r++) {
-        const a = Nt.nodeKey(i, r);
+        const a = vt.nodeKey(i, r);
         this.containerNodes.has(a) && (e[a] = n, n += 1);
       }
     }
@@ -7371,7 +7372,7 @@ class Nt extends W {
       const t = [];
       for (const e of this.layers)
         for (let n = 0; n < e.inboundNodes.length; ++n) {
-          const i = Nt.nodeKey(e, n);
+          const i = vt.nodeKey(e, n);
           this.containerNodes.has(i) && t.push(...e.calculateLosses());
         }
       return t;
@@ -7382,7 +7383,7 @@ class Nt extends W {
     for (const a of this.layers) {
       const o = a.getClassName(), l = a.getConfig(), u = [];
       for (let h = 0; h < a.inboundNodes.length; h++) {
-        const p = a.inboundNodes[h], f = Nt.nodeKey(a, h);
+        const p = a.inboundNodes[h], f = vt.nodeKey(a, h);
         let g = {};
         if (this.containerNodes.has(f)) {
           if (p.callArgs)
@@ -7394,9 +7395,9 @@ class Nt extends W {
           if (p.inboundLayers.length > 0) {
             const b = [];
             for (let m = 0; m < p.inboundLayers.length; m++) {
-              const N = p.inboundLayers[m], y = p.nodeIndices[m], C = p.tensorIndices[m], v = Nt.nodeKey(N, y);
-              let I = e[v];
-              I == null && (I = 0), b.push([N.name, I, C, g]);
+              const v = p.inboundLayers[m], y = p.nodeIndices[m], C = p.tensorIndices[m], N = vt.nodeKey(v, y);
+              let I = e[N];
+              I == null && (I = 0), b.push([v.name, I, C, g]);
             }
             u.push(b);
           }
@@ -7408,7 +7409,7 @@ class Nt extends W {
     t.layers = n;
     const i = [];
     for (let a = 0; a < this.inputLayers.length; a++) {
-      const o = this.inputLayers[a], l = this.inputLayersNodeIndices[a], u = Nt.nodeKey(o, l);
+      const o = this.inputLayers[a], l = this.inputLayersNodeIndices[a], u = vt.nodeKey(o, l);
       if (!this.containerNodes.has(u))
         continue;
       let c = e[u];
@@ -7419,7 +7420,7 @@ class Nt extends W {
     t.inputLayers = i;
     const r = [];
     for (let a = 0; a < this.outputLayers.length; a++) {
-      const o = this.outputLayers[a], l = this.outputLayersNodeIndices[a], u = Nt.nodeKey(o, l);
+      const o = this.outputLayers[a], l = this.outputLayersNodeIndices[a], u = vt.nodeKey(o, l);
       if (!this.containerNodes.has(u))
         continue;
       let c = e[u];
@@ -7444,21 +7445,21 @@ class Nt extends W {
   /** @nocollapse */
   static fromConfig(t, e, n = {}, i = !1) {
     const r = {}, a = {};
-    function o(m, N) {
-      m.name in a ? a[m.name].push(N) : a[m.name] = [N];
+    function o(m, v) {
+      m.name in a ? a[m.name].push(v) : a[m.name] = [v];
     }
-    function l(m, N) {
+    function l(m, v) {
       const y = [];
       let C;
-      for (const v of N) {
-        const I = v[0], z = v[1], _ = v[2];
-        if (C = v[3] == null ? {} : v[3], !(I in r)) {
-          o(m, N);
+      for (const N of v) {
+        const I = N[0], z = N[1], _ = N[2];
+        if (C = N[3] == null ? {} : N[3], !(I in r)) {
+          o(m, v);
           return;
         }
         const T = r[I];
         if (T.inboundNodes.length <= z) {
-          o(m, N);
+          o(m, v);
           return;
         }
         const E = T.inboundNodes[z];
@@ -7467,38 +7468,38 @@ class Nt extends W {
       y.length > 0 && m.apply(ht(y), C);
     }
     function u(m) {
-      const N = m.name, y = Wt(m, e.customObjects != null ? e.customObjects : {});
-      y.setFastWeightInitDuringBuild(i), r[N] = y, m.inboundNodes.forEach((v) => {
-        if (!(v instanceof Array))
-          throw new d(`Corrupted configuration, expected array for nodeData: ${v}`);
-        o(y, v);
+      const v = m.name, y = Wt(m, e.customObjects != null ? e.customObjects : {});
+      y.setFastWeightInitDuringBuild(i), r[v] = y, m.inboundNodes.forEach((N) => {
+        if (!(N instanceof Array))
+          throw new d(`Corrupted configuration, expected array for nodeData: ${N}`);
+        o(y, N);
       });
     }
     const c = e.name, h = e.layers;
     for (const m of h)
       u(m);
-    for (; !zu(a); )
+    for (; !Cu(a); )
       for (const m of h) {
-        const N = r[m.name];
-        if (N.name in a) {
-          const y = a[N.name];
-          delete a[N.name];
+        const v = r[m.name];
+        if (v.name in a) {
+          const y = a[v.name];
+          delete a[v.name];
           for (const C of y)
-            l(N, C);
+            l(v, C);
         }
       }
     const p = [], f = [], g = e.inputLayers;
     for (const m of g) {
-      const N = m[0], y = m[1], C = m[2];
-      Ut(N in r);
-      const I = r[N].inboundNodes[y].outputTensors;
+      const v = m[0], y = m[1], C = m[2];
+      Ut(v in r);
+      const I = r[v].inboundNodes[y].outputTensors;
       p.push(I[C]);
     }
     const b = e.outputLayers;
     for (const m of b) {
-      const N = m[0], y = m[1], C = m[2];
-      Ut(N in r);
-      const I = r[N].inboundNodes[y].outputTensors;
+      const v = m[0], y = m[1], C = m[2];
+      Ut(v in r);
+      const I = r[v].inboundNodes[y].outputTensors;
       f.push(I[C]);
     }
     return new t({ inputs: p, outputs: f, name: c });
@@ -7540,7 +7541,7 @@ class Nt extends W {
  * https://opensource.org/licenses/MIT.
  * =============================================================================
  */
-function Lf(s, t, e) {
+function Ff(s, t, e) {
   const n = t.length;
   if (s == null || Array.isArray(s) && s.length === 0)
     return t.map((i) => null);
@@ -7559,7 +7560,7 @@ function Lf(s, t, e) {
     throw new Error(`The model has multiple (${n}) outputs, so ${e} must be either an array with ${n} elements or an object with ${t} keys. Provided ${e} not understood: ${JSON.stringify(s)}`);
 }
 function Tr(s, t) {
-  return Lf(s, t, "classWeight");
+  return Ff(s, t, "classWeight");
 }
 async function $r(s, t, e, n) {
   if (e != null) {
@@ -7585,7 +7586,7 @@ async function $r(s, t, e, n) {
   } else
     return null;
 }
-function Ff(s, t) {
+function Mf(s, t) {
   return w(s, t);
 }
 /**
@@ -7597,7 +7598,7 @@ function Ff(s, t) {
  * https://opensource.org/licenses/MIT.
  * =============================================================================
  */
-const Mf = 32;
+const Of = 32;
 function Er(s, t) {
   let e, n;
   const i = t;
@@ -7625,12 +7626,12 @@ function ri(s, t, e) {
     return n;
   }
 }
-function Of(s) {
+function Rf(s) {
   if (s.length === 3)
     throw new G("Validation with sample weights is not implemented yet.");
   return { xs: s[0], ys: s[1] };
 }
-async function Rf(s, t, e) {
+async function _f(s, t, e) {
   const n = e.batchesPerEpoch != null;
   if (k(s.optimizer != null, () => "You must compile a model before training/testing. Use LayersModel.compile(modelCompileConfig)."), k(e != null, () => "For fitDataset(), the 2nd argument (config) is required, but it is not provided in this call."), k(e.epochs != null && e.epochs > 0 && Number.isInteger(e.epochs), () => `For fitDataset(), config.epochs is expected to be a positive integer, but got ${e.epochs}`), k(!n || e.batchesPerEpoch > 0 && Number.isInteger(e.batchesPerEpoch), () => `For fitDataset(), config.batchesPerEpoch is expected to be a positive integer if specified, but got ${e.batchesPerEpoch}`), k(
     // tslint:disable-next-line:no-any
@@ -7646,19 +7647,19 @@ async function Rf(s, t, e) {
       if (ai(e.validationData))
         k(e.validationBatches == null || e.validationBatches > 0 && Number.isInteger(e.validationBatches), () => `For fitDataset() with dataset-based validation, config.validationBatches is expected not to be provided, or to be a positive integer, but got ${e.validationBatches}`);
       else {
-        const m = Of(e.validationData);
+        const m = Rf(e.validationData);
         r = m.xs, a = m.ys;
       }
     const o = s.makeTrainFunction(), l = s.getDedupedMetricsNames();
     let u;
     i ? u = l.slice().concat(l.map((m) => "val_" + m)) : u = l.slice();
-    const c = xr(e.callbacks, e.yieldEvery), h = e.verbose == null ? 1 : e.verbose, { callbackList: p, history: f } = vr(
+    const c = xr(e.callbacks, e.yieldEvery), h = e.verbose == null ? 1 : e.verbose, { callbackList: p, history: f } = Nr(
       c,
       h,
       e.epochs,
       null,
       null,
-      _f(t, e),
+      Bf(t, e),
       null,
       // Batch size determined by the dataset itself.
       i,
@@ -7669,39 +7670,39 @@ async function Rf(s, t, e) {
     for (; g < e.epochs; ) {
       const m = {};
       await p.onEpochBegin(g);
-      let N = 0, y = 0;
-      for (n || (b = await t.iterator()); !n || N < e.batchesPerEpoch; ) {
+      let v = 0, y = 0;
+      for (n || (b = await t.iterator()); !n || v < e.batchesPerEpoch; ) {
         const C = await b.next();
         if (n && C.done) {
-          console.warn(`You provided \`batchesPerEpoch\` as ${e.batchesPerEpoch}, but your dataset iterator ran out of data after ${N} batches; interrupting training. Make sure that your dataset can generate at least \`batchesPerEpoch * epochs\` batches (in this case, ${e.batchesPerEpoch * e.epochs} batches). You may need to use the repeat() function when building your dataset.`);
+          console.warn(`You provided \`batchesPerEpoch\` as ${e.batchesPerEpoch}, but your dataset iterator ran out of data after ${v} batches; interrupting training. Make sure that your dataset can generate at least \`batchesPerEpoch * epochs\` batches (in this case, ${e.batchesPerEpoch * e.epochs} batches). You may need to use the repeat() function when building your dataset.`);
           break;
         }
         if (C.value != null) {
-          const { xs: v, ys: I } = Er(s, C.value), z = {};
-          z.batch = y, z.size = v[0].shape[0], await p.onBatchBegin(y, z);
+          const { xs: N, ys: I } = Er(s, C.value), z = {};
+          z.batch = y, z.size = N[0].shape[0], await p.onBatchBegin(y, z);
           const _ = [];
           if (e.classWeight != null) {
             const R = Tr(e.classWeight, s.outputNames);
             for (let q = 0; q < R.length; ++q)
               _.push(await $r(I[q], null, R[q]));
           }
-          const T = v.concat(I).concat(_), E = o(T);
+          const T = N.concat(I).concat(_), E = o(T);
           Z(T);
           for (let R = 0; R < l.length; ++R) {
             const q = l[R], bt = E[R];
             z[q] = bt, Bt(bt);
           }
-          await p.onBatchEnd(y, z), kr(z), y++, N++;
+          await p.onBatchEnd(y, z), kr(z), y++, v++;
         }
-        if (n ? N >= e.batchesPerEpoch : C.done) {
+        if (n ? v >= e.batchesPerEpoch : C.done) {
           if (i) {
-            let v;
-            ai(e.validationData) ? v = K(await s.evaluateDataset(e.validationData, { batches: e.validationBatches })) : v = K(s.evaluate(r, a, {
-              batchSize: e.validationBatchSize == null ? Mf : e.validationBatchSize,
+            let N;
+            ai(e.validationData) ? N = K(await s.evaluateDataset(e.validationData, { batches: e.validationBatches })) : N = K(s.evaluate(r, a, {
+              batchSize: e.validationBatchSize == null ? Of : e.validationBatchSize,
               verbose: 0
             }));
             for (let I = 0; I < s.metricsNames.length; ++I)
-              m[`val_${s.metricsNames[I]}`] = v[I];
+              m[`val_${s.metricsNames[I]}`] = N[I];
           }
           break;
         }
@@ -7716,24 +7717,24 @@ async function Rf(s, t, e) {
     s.isTraining = !1;
   }
 }
-function _f(s, t) {
+function Bf(s, t) {
   let e = null;
   return t.batchesPerEpoch != null ? e = t.batchesPerEpoch : Number.isFinite(s.size) && (e = s.size), e;
 }
 function ai(s) {
   return typeof s.iterator == "function";
 }
-function Bf(s) {
+function Wf(s) {
   return typeof s.next == "function";
 }
-async function Wf(s, t, e) {
+async function Gf(s, t, e) {
   e = e || {};
   const n = e.batches != null, i = s.testFunction;
   let r = [];
   if (e.verbose > 0)
     throw new G("Verbose mode is not implemented yet.");
   k(!n || e.batches > 0 && Number.isInteger(e.batches), () => `Test loop expects \`batches\` to be a positive integer, but received ${JSON.stringify(e.batches)}`);
-  const a = Bf(t) ? t : await t.iterator();
+  const a = Wf(t) ? t : await t.iterator();
   let o = 0, l = 0;
   for (; !n || l < e.batches; ) {
     const u = await a.next();
@@ -7745,8 +7746,8 @@ async function Wf(s, t, e) {
             r.push(tt(0));
         const g = p[0].shape[0];
         for (let b = 0; b < f.length; ++b) {
-          const m = f[b], N = r[b];
-          r[b] = x(() => $(r[b], w(g, m))), l > 0 && Z(N);
+          const m = f[b], v = r[b];
+          r[b] = x(() => $(r[b], w(g, m))), l > 0 && Z(v);
         }
         Z(f), o += g, ++l;
       }
@@ -7775,7 +7776,7 @@ function En(s) {
   k(s > 0 && Number.isInteger(s), () => `batchSize is required to be a positive integer, but got ${s}`);
 }
 function Te(s, t, e) {
-  return s == null ? [null] : Array.isArray(s) ? s.map((n) => nn(n, t, e - t)) : nn(s, t, e - t);
+  return s == null ? [null] : Array.isArray(s) ? s.map((n) => en(n, t, e - t)) : en(s, t, e - t);
 }
 function jn(s, t) {
   return x(() => s == null ? null : Array.isArray(s) ? s.map((e) => jn(e, t)) : Vi(s, t.dtype === "int32" ? t : L(t, "int32")));
@@ -7802,7 +7803,7 @@ function Lr(s) {
   }
   return t;
 }
-function vt(s, t) {
+function Nt(s, t) {
   if (s == null)
     return;
   const e = [];
@@ -7840,14 +7841,14 @@ function vt(s, t) {
  * https://opensource.org/licenses/MIT.
  * =============================================================================
  */
-function Gf(s) {
+function Pf(s) {
   return s instanceof xe;
 }
 function Kn(s) {
   return Array.isArray(s);
 }
 function oi(s) {
-  return !Gf(s) && !Kn(s);
+  return !Pf(s) && !Kn(s);
 }
 function li(s, t, e, n = !0, i = "") {
   if (t == null || t.length === 0) {
@@ -7904,7 +7905,7 @@ function li(s, t, e, n = !0, i = "") {
     }
   return r;
 }
-function Pf(s, t, e) {
+function Uf(s, t, e) {
   const n = jt(s.map((r) => r.shape[0]));
   n.sort();
   const i = jt(t.map((r) => r.shape[0]));
@@ -7915,9 +7916,9 @@ function Pf(s, t, e) {
   if (n.length > 0 && i.length > 0 && !Ft(n, i))
     throw new d(`Input Tensors should have the same number of samples as target Tensors. Found ${n[0]} input sample(s) and ${i[0]} target sample(s).`);
 }
-function Uf(s, t, e) {
+function Vf(s, t, e) {
   const n = [
-    Nn,
+    vn,
     Sn,
     Oe
   ];
@@ -7964,7 +7965,7 @@ function ui(s, t, e, n = !0, i = "") {
       }
     }
 }
-function Vf(s, t) {
+function jf(s, t) {
   if (s == null || Array.isArray(s) && s.length === 0)
     return t.map((n) => []);
   let e;
@@ -7985,8 +7986,8 @@ function Vf(s, t) {
     return n;
   }
 }
-const jf = "layers-model";
-class we extends Nt {
+const Kf = "layers-model";
+class we extends vt {
   constructor(t) {
     super(t), this.isTraining = !1;
   }
@@ -8028,7 +8029,7 @@ class we extends Nt {
   summary(t, e, n = console.log) {
     if (!this.built)
       throw new d("This model has never been called, thus its weights have not been created yet. So no summary can be displayed. Build the model first (e.g., by calling it on some test data).");
-    If(this, t, e, n);
+    Df(this, t, e, n);
   }
   /**
    * Configures and prepares the model for training and evaluation.  Compiling
@@ -8042,7 +8043,7 @@ class we extends Nt {
    */
   compile(t) {
     if (t.loss == null && (t.loss = []), this.loss = t.loss, typeof t.optimizer == "string")
-      this.optimizer_ = Cf(t.optimizer), this.isOptimizerOwned = !0;
+      this.optimizer_ = If(t.optimizer), this.isOptimizerOwned = !0;
     else {
       if (!(t.optimizer instanceof gu))
         throw new d("User-defined optimizer must be an instance of tf.Optimizer.");
@@ -8080,7 +8081,7 @@ class we extends Nt {
         this.outputs.length > 1 && (this.metricsTensors.push([o, a]), this.metricsNames.push(this.outputNames[a] + "_loss"));
       }
     });
-    const i = Vf(t.metrics, this.outputNames), r = (a, o, l) => {
+    const i = jf(t.metrics, this.outputNames), r = (a, o, l) => {
       this.outputNames.length > 1 && (o = this.outputNames[a] + "_" + o), this.metricsNames.push(o), this.metricsTensors.push([l, a]);
     };
     le("metric", () => {
@@ -8093,11 +8094,11 @@ class we extends Nt {
           for (const g of u) {
             if (typeof g == "string" && ["accuracy", "acc", "crossentropy", "ce"].indexOf(g) !== -1) {
               const m = this.internalOutputShapes[a];
-              m[m.length - 1] === 1 || this.lossFunctions[a] === Sn ? ["accuracy", "acc"].indexOf(g) !== -1 ? p = Sr : ["crossentropy", "ce"].indexOf(g) !== -1 && (p = gf) : this.lossFunctions[a] === dn ? ["accuracy", "acc"].indexOf(g) !== -1 ? p = bf : ["crossentropy", "ce"].indexOf(g) !== -1 && (p = Ir) : ["accuracy", "acc"].indexOf(g) !== -1 ? p = Ar : ["crossentropy", "ce"].indexOf(g) !== -1 && (p = Cr);
-              let N;
-              ["accuracy", "acc"].indexOf(g) !== -1 ? N = "acc" : ["crossentropy", "ce"].indexOf(g) !== -1 && (N = "ce"), f = p, h = "" + N;
+              m[m.length - 1] === 1 || this.lossFunctions[a] === Sn ? ["accuracy", "acc"].indexOf(g) !== -1 ? p = Sr : ["crossentropy", "ce"].indexOf(g) !== -1 && (p = bf) : this.lossFunctions[a] === dn ? ["accuracy", "acc"].indexOf(g) !== -1 ? p = yf : ["crossentropy", "ce"].indexOf(g) !== -1 && (p = Ir) : ["accuracy", "acc"].indexOf(g) !== -1 ? p = Ar : ["crossentropy", "ce"].indexOf(g) !== -1 && (p = Cr);
+              let v;
+              ["accuracy", "acc"].indexOf(g) !== -1 ? v = "acc" : ["crossentropy", "ce"].indexOf(g) !== -1 && (v = "ce"), f = p, h = "" + v;
             } else
-              f = Af(g), h = "" + tn(g);
+              f = Cf(g), h = "" + tn(g);
             let b;
             le(h, () => {
               b = f;
@@ -8160,7 +8161,7 @@ class we extends Nt {
       const l = this.testFunction, u = this.testLoop(l, o, i, n.verbose, n.steps);
       return ht(u);
     } finally {
-      vt(a[0], t), vt(a[1], e);
+      Nt(a[0], t), Nt(a[1], e);
     }
   }
   // TODO(cais): Add code snippet below once real dataset objects are
@@ -8186,7 +8187,7 @@ class we extends Nt {
    * @doc {heading: 'Models', subheading: 'Classes'}
    */
   async evaluateDataset(t, e) {
-    return this.makeTestFunction(), Wf(this, t, e);
+    return this.makeTestFunction(), Gf(this, t, e);
   }
   /**
    * Get number of samples provided for training, evaluation or prediction.
@@ -8239,7 +8240,7 @@ class we extends Nt {
    * Retrieve the model's internal symbolic tensors from symbolic-tensor names.
    */
   retrieveSymbolicTensors(t) {
-    const e = ce(null, t.length);
+    const e = ue(null, t.length);
     let n = t.length;
     for (const i of this.layers) {
       const r = Array.isArray(i.output) ? i.output : [i.output], a = r.map((o) => o.name);
@@ -8326,7 +8327,7 @@ class we extends Nt {
       const i = e.batchSize == null ? 32 : e.batchSize;
       return En(i), this.predictLoop(n, i);
     } finally {
-      vt(n, t);
+      Nt(n, t);
     }
   }
   /**
@@ -8357,7 +8358,7 @@ class we extends Nt {
       const o = this.feedOutputShapes[a];
       this.feedLossFns[a] === dn ? r.push(o.slice(0, o.length - 1).concat([1])) : r.push(o);
     }
-    if (t = li(t, this.feedInputNames, this.feedInputShapes, !1, "input"), e = li(e, this.feedOutputNames, r, !1, "target"), Pf(t, e), Uf(e, this.feedLossFns, this.feedOutputShapes), this.stateful && i != null && i > 0 && t[0].shape[0] % i !== 0)
+    if (t = li(t, this.feedInputNames, this.feedInputShapes, !1, "input"), e = li(e, this.feedOutputNames, r, !1, "target"), Uf(t, e), Vf(e, this.feedLossFns, this.feedOutputShapes), this.stateful && i != null && i > 0 && t[0].shape[0] % i !== 0)
       throw new d(`In a stateful network, you should only pass inputs with a number of samples that is divisible by the batch size ${i}. Found: ${t[0].shape[0]} sample(s).`);
     return [t, e];
   }
@@ -8395,13 +8396,13 @@ class we extends Nt {
       {
         const l = Ln(a, n), u = Rn(It(0, a));
         for (let c = 0; c < l.length; ++c) {
-          const h = l[c][0], p = l[c][1], f = nn(u, h, p - h), g = jn(e, f), b = t(g);
+          const h = l[c][0], p = l[c][1], f = en(u, h, p - h), g = jn(e, f), b = t(g);
           if (c === 0)
             for (let m = 0; m < b.length; ++m)
               o.push(tt(0));
           for (let m = 0; m < b.length; ++m) {
-            const N = b[m];
-            o[m] = $(o[m], w(p - h, N));
+            const v = b[m];
+            o[m] = $(o[m], w(p - h, v));
           }
         }
         for (let c = 0; c < o.length; ++c)
@@ -8443,18 +8444,18 @@ class we extends Nt {
         let g;
         for (let b = 0; b < this.lossFunctions.length; ++b) {
           const m = this.lossFunctions[b];
-          let N = m(i[b], f[b]);
-          r[b] != null && (N = Ff(N, r[b]));
-          const y = at(N);
-          e.push(y), b === 0 ? g = N : g = $(g, N);
+          let v = m(i[b], f[b]);
+          r[b] != null && (v = Mf(v, r[b]));
+          const y = at(v);
+          e.push(y), b === 0 ? g = v : g = $(g, v);
         }
         for (let b = 0; b < this.metricsTensors.length; ++b) {
           let m;
           if (this.outputs.length > 1 && b < this.outputs.length)
             m = e[b];
           else {
-            const N = this.metricsTensors[b][0], y = this.metricsTensors[b][1];
-            m = at(N(i[y], f[y]));
+            const v = this.metricsTensors[b][0], y = this.metricsTensors[b][1];
+            m = at(v(i[y], f[y]));
           }
           Bt(m), a.push(m);
         }
@@ -8533,7 +8534,7 @@ class we extends Nt {
       En(f);
       const b = await this.standardizeUserData(t, e, n.sampleWeight, n.classWeight, !1, f);
       i = b[0], r = b[1], p = b[2];
-      let m = !1, N;
+      let m = !1, v;
       if (n.validationData != null && n.validationData.length > 0) {
         if (m = !0, n.validationData.length === 2)
           l = n.validationData[0], u = n.validationData[1];
@@ -8547,21 +8548,21 @@ class we extends Nt {
           !0,
           f
         );
-        c = R[0], h = R[1], N = c.concat(h);
+        c = R[0], h = R[1], v = c.concat(h);
       } else if (n.validationSplit != null && n.validationSplit > 0 && n.validationSplit < 1) {
         m = !0;
         const E = Math.floor(i[0].shape[0] * (1 - n.validationSplit)), R = i[0].shape[0];
-        c = Te(i, E, R), a = i, i = Te(i, 0, E), h = Te(r, E, R), o = r, r = Te(r, 0, E), N = c.concat(h);
+        c = Te(i, E, R), a = i, i = Te(i, 0, E), h = Te(r, E, R), o = r, r = Te(r, 0, E), v = c.concat(h);
       } else n.validationSteps != null && (m = !0);
       const y = i.concat(r).concat(p);
       this.checkTrainableWeightsConsistency();
-      const C = this.makeTrainFunction(), v = this.getDedupedMetricsNames();
+      const C = this.makeTrainFunction(), N = this.getDedupedMetricsNames();
       let I, z;
-      m ? (this.makeTestFunction(), I = this.testFunction, z = v.slice().concat(v.map((E) => "val_" + E))) : (I = null, N = [], z = v.slice());
+      m ? (this.makeTestFunction(), I = this.testFunction, z = N.slice().concat(N.map((E) => "val_" + E))) : (I = null, v = [], z = N.slice());
       const _ = xr(n.callbacks, n.yieldEvery);
-      return await this.fitLoop(C, y, v, f, n.epochs, n.verbose, _, I, N, n.shuffle, z, n.initialEpoch, null, null);
+      return await this.fitLoop(C, y, N, f, n.epochs, n.verbose, _, I, v, n.shuffle, z, n.initialEpoch, null, null);
     } finally {
-      this.isTraining = !1, vt(i, t), vt(r, e), vt(a, t), vt(o, e), vt(c, l), vt(h, u), p != null && Z(p);
+      this.isTraining = !1, Nt(i, t), Nt(r, e), Nt(a, t), Nt(o, e), Nt(c, l), Nt(h, u), p != null && Z(p);
     }
   }
   /**
@@ -8597,24 +8598,24 @@ class we extends Nt {
     if (l != null && u != null && (b = !0), g != null && (b = !0, f == null))
       throw new d("Can only use `validationSteps` when doing step-wise training, i.e., `stepsPerEpoch` must be set.");
     const m = this.checkNumSamples(e, i, f, "steps_per_epoch");
-    let N;
-    m != null && (N = It(0, m)), a == null && (a = 1);
-    const { callbackList: y, history: C } = vr(o, a, r, p, m, f, i, b, h);
+    let v;
+    m != null && (v = It(0, m)), a == null && (a = 1);
+    const { callbackList: y, history: C } = Nr(o, a, r, p, m, f, i, b, h);
     y.setModel(this), this.history = C, await y.onTrainBegin(), this.stopTraining_ = !1;
-    for (let v = p; v < r; ++v) {
-      await y.onEpochBegin(v);
+    for (let N = p; N < r; ++N) {
+      await y.onEpochBegin(N);
       const I = {};
       if (f != null)
         throw new G("stepsPerEpoch mode is not implemented yet.");
       {
         if (c === "batch")
           throw new G("batch shuffling is not implemneted yet");
-        c && bu(N);
-        const z = Rn(N), _ = Ln(m, i);
+        c && bu(v);
+        const z = Rn(v), _ = Ln(m, i);
         for (let T = 0; T < _.length; ++T) {
           const E = {};
           if (await y.onBatchBegin(T, E), x(() => {
-            const R = _[T][0], q = _[T][1], bt = nn(z, R, q - R);
+            const R = _[T][0], q = _[T][1], bt = en(z, R, q - R);
             E.batch = T, E.size = q - R;
             const ie = jn(e, bt), re = t(ie);
             for (let xt = 0; xt < n.length; ++xt) {
@@ -8633,7 +8634,7 @@ class we extends Nt {
         }
         z.dispose();
       }
-      if (await y.onEpochEnd(v, I), this.stopTraining_)
+      if (await y.onEpochEnd(N, I), this.stopTraining_)
         break;
     }
     return await y.onTrainEnd(), await this.history.syncData(), this.history;
@@ -8662,7 +8663,7 @@ class we extends Nt {
    * @doc {heading: 'Models', subheading: 'Classes'}
    */
   async fitDataset(t, e) {
-    return Rf(this, t, e);
+    return _f(this, t, e);
   }
   /**
    * Runs a single gradient update on a single batch of data.
@@ -8693,7 +8694,7 @@ class we extends Nt {
       const c = await u.data();
       l.push(c[0]);
     }
-    return Z(o), vt(n[0], t), vt(n[1], e), ht(l);
+    return Z(o), Nt(n[0], t), Nt(n[1], e), ht(l);
   }
   /**
    * Extract weight values of the model.
@@ -8925,7 +8926,7 @@ class we extends Nt {
       throw new d("LayersModel.save() cannot proceed because the IOHandler provided does not have the `save` attribute defined.");
     const n = await Os(this.getNamedWeights(e)), o = {
       modelTopology: this.toJSON(null, !1),
-      format: jf,
+      format: Kf,
       generatedBy: `TensorFlow.js tfjs-layers v${zr}`,
       convertedBy: null
     };
@@ -9023,7 +9024,7 @@ class Re extends we {
       if (t.inboundNodes.length === 0) {
         if (t.batchInputShape == null)
           throw new d("The first layer in a Sequential model must get an `inputShape` or `batchInputShape` argument.");
-        const i = Gh({
+        const i = Ph({
           batchShape: t.batchInputShape,
           dtype: t.dtype,
           name: t.name + "_input"
@@ -9039,7 +9040,7 @@ class Re extends we {
           throw new d("All layers in a Sequential model should have a single output tensor. For multi-output layers, use the functional API.");
         this.checkShape(t), this.outputs = [t.inboundNodes[0].outputTensors[0]], this.inputs = dr(this.outputs[0]);
       }
-      this.inboundNodes = [], new vn({
+      this.inboundNodes = [], new Nn({
         outboundLayer: this,
         inboundLayers: [],
         nodeIndices: [],
@@ -9047,7 +9048,7 @@ class Re extends we {
         inputTensors: this.inputs,
         outputTensors: this.outputs,
         // no model-level masking for now
-        inputMasks: ce(null, this.inputs.length),
+        inputMasks: ue(null, this.inputs.length),
         outputMasks: [null],
         inputShapes: this.inputs.map((i) => i.shape),
         outputShapes: this.outputs[0].shape
@@ -9495,28 +9496,28 @@ class Mr extends ut {
    * @return Output of the ELU activation.
    */
   apply(t, e = 1) {
-    return Tu(t, e);
+    return Iu(t, e);
   }
 }
 Mr.className = "elu";
 S(Mr);
 class Or extends ut {
   apply(t) {
-    return oh(t);
+    return lh(t);
   }
 }
 Or.className = "selu";
 S(Or);
 class Rr extends ut {
   apply(t) {
-    return Ve(t);
+    return Pe(t);
   }
 }
 Rr.className = "relu";
 S(Rr);
 class _r extends ut {
   apply(t) {
-    return x(() => ji(6, Ve(t)));
+    return x(() => Zi(6, Pe(t)));
   }
 }
 _r.className = "relu6";
@@ -9530,14 +9531,14 @@ Br.className = "linear";
 S(Br);
 class Wr extends ut {
   apply(t) {
-    return Qn(t);
+    return Yn(t);
   }
 }
 Wr.className = "sigmoid";
 S(Wr);
 class Gr extends ut {
   apply(t) {
-    return $u(t);
+    return Du(t);
   }
 }
 Gr.className = "hardSigmoid";
@@ -9551,7 +9552,7 @@ Pr.className = "softplus";
 S(Pr);
 class Ur extends ut {
   apply(t) {
-    return Eu(t);
+    return zu(t);
   }
 }
 Ur.className = "softsign";
@@ -9563,7 +9564,7 @@ class Vr extends ut {
 }
 Vr.className = "tanh";
 S(Vr);
-let Ns = class extends ut {
+let vs = class extends ut {
   /**
    * Calculate the activation function.
    *
@@ -9580,8 +9581,8 @@ let Ns = class extends ut {
     return tr(t, e);
   }
 };
-Ns.className = "softmax";
-S(Ns);
+vs.className = "softmax";
+S(vs);
 class jr extends ut {
   /**
    * Calculate the activation function of log softmax:
@@ -9597,7 +9598,7 @@ class jr extends ut {
    * @throws ValueError: In case `dim(x) < 2`.
    */
   apply(t, e = -1) {
-    return Uc(t, e);
+    return Vc(t, e);
   }
 }
 jr.className = "logSoftmax";
@@ -9611,7 +9612,7 @@ class Kr extends ut {
    */
   apply(t) {
     return x(() => x(() => {
-      const e = Math.sqrt(2), n = w(0.5, $(1, _c(P(t, e))));
+      const e = Math.sqrt(2), n = w(0.5, $(1, Bc(P(t, e))));
       return w(t, n);
     }));
   }
@@ -9653,7 +9654,7 @@ class Zr extends ut {
    * @returns a Tensor of the same shape as x
    */
   apply(t, e = 1) {
-    return x(() => w(Qn(w(t, e)), t));
+    return x(() => w(Yn(w(t, e)), t));
   }
 }
 Zr.className = "swish";
@@ -9683,7 +9684,7 @@ function Qt(s) {
  * https://opensource.org/licenses/MIT.
  * =============================================================================
  */
-function Kf(s) {
+function Hf(s) {
   if (s != null && typeof s != "object")
     throw new Error(`Argument to L1L2 regularizer's constructor is expected to be an object, but received: ${s}`);
 }
@@ -9691,7 +9692,7 @@ class Jr extends Be {
 }
 class Xr extends Jr {
   constructor(t) {
-    super(), Kf(t), this.l1 = t == null || t.l1 == null ? 0.01 : t.l1, this.l2 = t == null || t.l2 == null ? 0.01 : t.l2, this.hasL1 = this.l1 !== 0, this.hasL2 = this.l2 !== 0;
+    super(), Hf(t), this.l1 = t == null || t.l1 == null ? 0.01 : t.l1, this.l2 = t == null || t.l2 == null ? 0.01 : t.l2, this.hasL1 = this.l1 !== 0, this.hasL2 = this.l2 !== 0;
   }
   /**
    * Porting note: Renamed from __call__.
@@ -9700,7 +9701,7 @@ class Xr extends Jr {
   apply(t) {
     return x(() => {
       let e = mt([1]);
-      return this.hasL1 && (e = $(e, B(w(this.l1, Fe(t))))), this.hasL2 && (e = $(e, B(w(this.l2, je(t))))), A(e, []);
+      return this.hasL1 && (e = $(e, B(w(this.l1, Fe(t))))), this.hasL2 && (e = $(e, B(w(this.l2, Ue(t))))), A(e, []);
     });
   }
   getConfig() {
@@ -9745,7 +9746,7 @@ class Yr extends W {
   }
   call(t, e) {
     t = O(t);
-    let n = Ve(t);
+    let n = Pe(t);
     return this.maxValue != null && (n = Ct(n, 0, this.maxValue)), n;
   }
   computeOutputShape(t) {
@@ -9764,7 +9765,7 @@ class Qr extends W {
   }
   call(t, e) {
     const n = O(t);
-    return Lu(n, this.alpha);
+    return Tu(n, this.alpha);
   }
   computeOutputShape(t) {
     return t;
@@ -9804,7 +9805,7 @@ class ta extends W {
     })], this.built = !0;
   }
   call(t, e) {
-    return t = O(t), Fu(t, this.alpha.read());
+    return t = O(t), $u(t, this.alpha.read());
   }
   getConfig() {
     const t = {
@@ -9826,7 +9827,7 @@ class ea extends W {
   }
   call(t, e) {
     const n = O(t);
-    return Mu(n);
+    return Eu(n);
   }
   computeOutputShape(t) {
     return t;
@@ -9858,7 +9859,7 @@ na.className = "ThresholdedReLU";
 S(na);
 class sa extends W {
   constructor(t) {
-    super(t ?? {}), this.DEFAULT_AXIS = 1, t == null && (t = {}), this.softmax = new Ns().apply, this.axis = t.axis == null ? this.DEFAULT_AXIS : t.axis;
+    super(t ?? {}), this.DEFAULT_AXIS = 1, t == null && (t = {}), this.softmax = new vs().apply, this.axis = t.axis == null ? this.DEFAULT_AXIS : t.axis;
   }
   call(t, e) {
     return x(() => {
@@ -9868,7 +9869,7 @@ class sa extends W {
         const r = w(V(pe(n.shape), L(i, n.dtype)), tt(-1e9));
         n = $(n, r);
       }
-      return this.axis instanceof Array ? this.axis.length > 1 ? Jt(V(n, Vu(n, this.axis, !0))) : this.softmax(n, this.axis[0]) : this.softmax(n, this.axis);
+      return this.axis instanceof Array ? this.axis.length > 1 ? Jt(V(n, ju(n, this.axis, !0))) : this.softmax(n, this.axis[0]) : this.softmax(n, this.axis);
     });
   }
   computeOutputShape(t) {
@@ -9892,12 +9893,12 @@ S(sa);
  */
 function ke(s, t, e) {
   if (typeof s == "number")
-    return ce(s, t);
+    return ue(s, t);
   if (s.length !== t)
     throw new d(`The ${e} argument must be an integer or tuple of ${t} integers. Received: ${s.length} elements.`);
   for (let n = 0; n < t; ++n) {
     const i = s[n];
-    if (!Ou(i))
+    if (!Lu(i))
       throw new d(`The ${e} argument must be an integer or tuple of ${t} integers. Received: ${JSON.stringify(s)} including a non-integer number ${i}`);
   }
   return s;
@@ -9913,7 +9914,7 @@ function $t(s, t, e, n) {
   if (s == null)
     return null;
   if (n === "valid")
-    s = s * t + qt([e - t, 0]);
+    s = s * t + Ht([e - t, 0]);
   else if (n === "same")
     s = s * t;
   else
@@ -9935,7 +9936,7 @@ function Ss(s, t) {
 function ia(s, t) {
   return x(() => (et(t), t === "channelsFirst" ? j(s, [0, 2, 3, 4, 1]) : s));
 }
-function Hf(s, t, e, n = 1, i = "valid", r, a = 1) {
+function qf(s, t, e, n = 1, i = "valid", r, a = 1) {
   return x(() => {
     if (r == null && (r = ne()), et(r), s.shape.length !== 3)
       throw new d(`The input of a conv1dWithBias operation should be 3, but is ${s.shape.length} instead.`);
@@ -9945,7 +9946,7 @@ function Hf(s, t, e, n = 1, i = "valid", r, a = 1) {
       throw new d(`The bias for a conv1dWithBias operation should be 1, but is ${e.shape.length} instead`);
     if (r === "channelsFirst" && (s = j(s, [0, 2, 1])), i === "causal")
       throw new G("The support for CAUSAL padding mode in conv1dWithBias is not implemented yet.");
-    let o = kc(s, t, n, i === "same" ? "same" : "valid", "NWC", a);
+    let o = xc(s, t, n, i === "same" ? "same" : "valid", "NWC", a);
     return e != null && (o = zt(o, e)), o;
   });
 }
@@ -9958,7 +9959,7 @@ function pi(s, t, e, n = [1, 1], i = "valid", r, a, o = null) {
     let l = Ss(s, r);
     if (i === "causal")
       throw new G("The support for CAUSAL padding mode in conv1dWithBias is not implemented yet.");
-    return l = bh({
+    return l = yh({
       x: l,
       filter: t,
       strides: n,
@@ -9970,7 +9971,7 @@ function pi(s, t, e, n = [1, 1], i = "valid", r, a, o = null) {
     }), r === "channelsFirst" && (l = j(l, [0, 3, 1, 2])), l;
   });
 }
-function qf(s, t, e, n = [1, 1, 1], i = "valid", r, a) {
+function Zf(s, t, e, n = [1, 1, 1], i = "valid", r, a) {
   return x(() => {
     if (r == null && (r = ne()), et(r), s.rank !== 4 && s.rank !== 5)
       throw new d(`conv3dWithBias expects input to be of rank 4 or 5, but received ${s.rank}.`);
@@ -9979,7 +9980,7 @@ function qf(s, t, e, n = [1, 1, 1], i = "valid", r, a) {
     let o = ia(s, r);
     if (i === "causal")
       throw new G("The support for CAUSAL padding mode in conv3dWithBias is not implemented yet.");
-    return o = Ac(o, t, n, i === "same" ? "same" : "valid", "NDHWC", a), e != null && (o = zt(o, e)), r === "channelsFirst" && (o = j(o, [0, 4, 1, 2, 3])), o;
+    return o = Cc(o, t, n, i === "same" ? "same" : "valid", "NDHWC", a), e != null && (o = zt(o, e)), r === "channelsFirst" && (o = j(o, [0, 4, 1, 2, 3])), o;
   });
 }
 class An extends W {
@@ -10001,7 +10002,7 @@ class An extends W {
     }
   }
   static verifyArgs(t) {
-    if (Ut("kernelSize" in t, "required key 'kernelSize' not in config"), typeof t.kernelSize != "number" && !es(t.kernelSize, "number", 1, 3))
+    if (Ut("kernelSize" in t, "required key 'kernelSize' not in config"), typeof t.kernelSize != "number" && !Qn(t.kernelSize, "number", 1, 3))
       throw new d(`BaseConv expects config.kernelSize to be number or number[] with length 1, 2, or 3, but received ${JSON.stringify(t.kernelSize)}.`);
   }
   getConfig() {
@@ -10037,16 +10038,16 @@ class De extends An {
     return x(() => {
       t = O(t);
       let n;
-      const i = this.bias == null ? null : this.bias.read(), r = Ki(this.activation.getClassName());
+      const i = this.bias == null ? null : this.bias.read(), r = ji(this.activation.getClassName());
       if (r != null && this.rank === 2)
         n = pi(t, this.kernel.read(), i, this.strides, this.padding, this.dataFormat, this.dilationRate, r);
       else {
         if (this.rank === 1)
-          n = Hf(t, this.kernel.read(), i, this.strides[0], this.padding, this.dataFormat, this.dilationRate[0]);
+          n = qf(t, this.kernel.read(), i, this.strides[0], this.padding, this.dataFormat, this.dilationRate[0]);
         else if (this.rank === 2)
           n = pi(t, this.kernel.read(), i, this.strides, this.padding, this.dataFormat, this.dilationRate);
         else if (this.rank === 3)
-          n = qf(t, this.kernel.read(), i, this.strides, this.padding, this.dataFormat, this.dilationRate);
+          n = Zf(t, this.kernel.read(), i, this.strides, this.padding, this.dataFormat, this.dilationRate);
         else
           throw new G("convolutions greater than 3D are not implemented yet.");
         this.activation != null && (n = this.activation.apply(n));
@@ -10087,7 +10088,7 @@ class Ze extends De {
     return delete t.rank, t;
   }
   static verifyArgs(t) {
-    if (typeof t.kernelSize != "number" && !es(t.kernelSize, "number", 1, 2))
+    if (typeof t.kernelSize != "number" && !Qn(t.kernelSize, "number", 1, 2))
       throw new d(`Conv2D expects config.kernelSize to be number or number[] with length 1 or 2, but received ${JSON.stringify(t.kernelSize)}.`);
   }
 }
@@ -10132,8 +10133,8 @@ class ra extends Ze {
       this.dataFormat === "channelsFirst" ? (a = 2, o = 3) : (a = 1, o = 2);
       const l = i[a], u = i[o], c = this.kernelSize[0], h = this.kernelSize[1], p = this.strides[0], f = this.strides[1], g = $t(l, p, c, this.padding), b = $t(u, f, h, this.padding), m = [r, g, b, this.filters];
       this.dataFormat !== "channelsLast" && (n = j(n, [0, 2, 3, 1]));
-      let N = Nc(n, this.kernel.read(), m, this.strides, this.padding);
-      return this.dataFormat !== "channelsLast" && (N = j(N, [0, 3, 1, 2])), this.bias != null && (N = zt(N, this.bias.read(), this.dataFormat)), this.activation != null && (N = this.activation.apply(N)), N;
+      let v = Sc(n, this.kernel.read(), m, this.strides, this.padding);
+      return this.dataFormat !== "channelsLast" && (v = j(v, [0, 3, 1, 2])), this.bias != null && (v = zt(v, this.bias.read(), this.dataFormat)), this.activation != null && (v = this.activation.apply(v)), v;
     });
   }
   computeOutputShape(t) {
@@ -10173,9 +10174,9 @@ class aa extends Je {
       const i = n.shape, r = i[0];
       let a, o, l;
       this.dataFormat === "channelsFirst" ? (l = 2, a = 3, o = 4) : (l = 1, a = 2, o = 3);
-      const u = i[l], c = i[a], h = i[o], p = this.kernelSize[0], f = this.kernelSize[1], g = this.kernelSize[2], b = this.strides[0], m = this.strides[1], N = this.strides[2], y = $t(u, b, p, this.padding), C = $t(c, m, f, this.padding), v = $t(h, N, g, this.padding), I = [r, y, C, v, this.filters];
+      const u = i[l], c = i[a], h = i[o], p = this.kernelSize[0], f = this.kernelSize[1], g = this.kernelSize[2], b = this.strides[0], m = this.strides[1], v = this.strides[2], y = $t(u, b, p, this.padding), C = $t(c, m, f, this.padding), N = $t(h, v, g, this.padding), I = [r, y, C, N, this.filters];
       this.dataFormat !== "channelsLast" && (n = j(n, [0, 2, 3, 4, 1]));
-      let z = Dc(n, this.kernel.read(), I, this.strides, this.padding);
+      let z = zc(n, this.kernel.read(), I, this.strides, this.padding);
       return this.dataFormat !== "channelsLast" && (z = j(z, [0, 4, 1, 2, 3])), this.bias !== null && (z = zt(z, this.bias.read(), this.dataFormat)), this.activation !== null && (z = this.activation.apply(z)), z;
     });
   }
@@ -10223,7 +10224,7 @@ class oa extends De {
       let n;
       if (this.rank === 1)
         throw new G("1D separable convolution is not implemented yet.");
-      return this.rank === 2 && (this.dataFormat === "channelsFirst" && (t = j(t, [0, 2, 3, 1])), n = uh(t, this.depthwiseKernel.read(), this.pointwiseKernel.read(), this.strides, this.padding, this.dilationRate, "NHWC")), this.useBias && (n = zt(n, this.bias.read(), this.dataFormat)), this.activation != null && (n = this.activation.apply(n)), this.dataFormat === "channelsFirst" && (n = j(n, [0, 3, 1, 2])), n;
+      return this.rank === 2 && (this.dataFormat === "channelsFirst" && (t = j(t, [0, 2, 3, 1])), n = ch(t, this.depthwiseKernel.read(), this.pointwiseKernel.read(), this.strides, this.padding, this.dilationRate, "NHWC")), this.useBias && (n = zt(n, this.bias.read(), this.dataFormat)), this.activation != null && (n = this.activation.apply(n)), this.dataFormat === "channelsFirst" && (n = j(n, [0, 3, 1, 2])), n;
     });
   }
   getConfig() {
@@ -10248,7 +10249,7 @@ class Cn extends De {
     return delete t.rank, delete t.dataFormat, t;
   }
   static verifyArgs(t) {
-    if (typeof t.kernelSize != "number" && !es(t.kernelSize, "number", 1, 1))
+    if (typeof t.kernelSize != "number" && !Qn(t.kernelSize, "number", 1, 1))
       throw new d(`Conv1D expects config.kernelSize to be number or number[] with length 1, but received ${JSON.stringify(t.kernelSize)}.`);
   }
 }
@@ -10294,7 +10295,7 @@ ua.className = "Cropping2D";
 S(ua);
 class ca extends W {
   constructor(t) {
-    super(t), this.DEFAULT_SIZE = [2, 2], this.inputSpec = [{ ndim: 4 }], this.size = t.size == null ? this.DEFAULT_SIZE : t.size, this.dataFormat = t.dataFormat == null ? "channelsLast" : t.dataFormat, et(this.dataFormat), this.interpolation = t.interpolation == null ? "nearest" : t.interpolation, Ru(this.interpolation);
+    super(t), this.DEFAULT_SIZE = [2, 2], this.inputSpec = [{ ndim: 4 }], this.size = t.size == null ? this.DEFAULT_SIZE : t.size, this.dataFormat = t.dataFormat == null ? "channelsLast" : t.dataFormat, et(this.dataFormat), this.interpolation = t.interpolation == null ? "nearest" : t.interpolation, Fu(this.interpolation);
   }
   computeOutputShape(t) {
     if (this.dataFormat === "channelsFirst") {
@@ -10339,7 +10340,7 @@ S(ca);
  * https://opensource.org/licenses/MIT.
  * =============================================================================
  */
-function Zf(s, t, e = [1, 1], n = "valid", i, r) {
+function Jf(s, t, e = [1, 1], n = "valid", i, r) {
   return x(() => {
     i == null && (i = ne()), et(i);
     let a = Ss(s, i);
@@ -10371,7 +10372,7 @@ class ha extends An {
   call(t, e) {
     return x(() => {
       t = O(t);
-      let n = Zf(t, this.depthwiseKernel.read(), this.strides, this.padding, this.dataFormat, null);
+      let n = Jf(t, this.depthwiseKernel.read(), this.strides, this.padding, this.dataFormat, null);
       return this.useBias && (n = zt(n, this.bias.read(), this.dataFormat)), this.activation != null && (n = this.activation.apply(n)), n;
     });
   }
@@ -10413,22 +10414,22 @@ function da(s, t, e, n = !1, i, r, a = !1, o = !1) {
     if (l < 3)
       throw new d(`Input should be at least 3D, but is ${l}D.`);
     const u = [1, 0].concat(It(2, l));
-    t = j(t, u), a && console.warn("Backend rnn(): the unroll = true option is not applicable to the imperative deeplearn.js backend."), i != null && (i = L(L(i, "bool"), "float32"), i.rank === l - 1 && (i = ue(i, -1)), i = j(i, u)), n && (t = on(t, 0), i != null && (i = on(i, 0)));
+    t = j(t, u), a && console.warn("Backend rnn(): the unroll = true option is not applicable to the imperative deeplearn.js backend."), i != null && (i = L(L(i, "bool"), "float32"), i.rank === l - 1 && (i = ce(i, -1)), i = j(i, u)), n && (t = on(t, 0), i != null && (i = on(i, 0)));
     const c = [];
     let h, p = e;
-    const f = t.shape[0], g = en(t);
+    const f = t.shape[0], g = nn(t);
     let b;
-    i != null && (b = en(i));
-    for (let N = 0; N < f; ++N) {
-      const y = g[N], C = x(() => s(y, p));
+    i != null && (b = nn(i));
+    for (let v = 0; v < f; ++v) {
+      const y = g[v], C = x(() => s(y, p));
       if (i == null)
         h = C[0], p = C[1];
       else {
-        const v = x(() => {
-          const I = b[N], z = V(Dt(I), I), _ = $(w(C[0], I), w(p[0], z)), T = p.map((E, R) => $(w(C[1][R], I), w(E, z)));
+        const N = x(() => {
+          const I = b[v], z = V(Dt(I), I), _ = $(w(C[0], I), w(p[0], z)), T = p.map((E, R) => $(w(C[1][R], I), w(E, z)));
           return { output: _, newStates: T };
         });
-        h = v.output, p = v.newStates;
+        h = N.output, p = N.newStates;
       }
       o && c.push(h);
     }
@@ -10642,9 +10643,9 @@ class In extends W {
 }
 class As extends In {
   constructor(t) {
-    super(t), this.DEFAULT_ACTIVATION = "tanh", this.DEFAULT_KERNEL_INITIALIZER = "glorotNormal", this.DEFAULT_RECURRENT_INITIALIZER = "orthogonal", this.DEFAULT_BIAS_INITIALIZER = "zeros", this.units = t.units, ot(this.units, "units"), this.activation = Qt(t.activation == null ? this.DEFAULT_ACTIVATION : t.activation), this.useBias = t.useBias == null ? !0 : t.useBias, this.kernelInitializer = J(t.kernelInitializer || this.DEFAULT_KERNEL_INITIALIZER), this.recurrentInitializer = J(t.recurrentInitializer || this.DEFAULT_RECURRENT_INITIALIZER), this.biasInitializer = J(t.biasInitializer || this.DEFAULT_BIAS_INITIALIZER), this.kernelRegularizer = X(t.kernelRegularizer), this.recurrentRegularizer = X(t.recurrentRegularizer), this.biasRegularizer = X(t.biasRegularizer), this.kernelConstraint = rt(t.kernelConstraint), this.recurrentConstraint = rt(t.recurrentConstraint), this.biasConstraint = rt(t.biasConstraint), this.dropout = ve([1, qt([0, t.dropout == null ? 0 : t.dropout])]), this.recurrentDropout = ve([
+    super(t), this.DEFAULT_ACTIVATION = "tanh", this.DEFAULT_KERNEL_INITIALIZER = "glorotNormal", this.DEFAULT_RECURRENT_INITIALIZER = "orthogonal", this.DEFAULT_BIAS_INITIALIZER = "zeros", this.units = t.units, ot(this.units, "units"), this.activation = Qt(t.activation == null ? this.DEFAULT_ACTIVATION : t.activation), this.useBias = t.useBias == null ? !0 : t.useBias, this.kernelInitializer = J(t.kernelInitializer || this.DEFAULT_KERNEL_INITIALIZER), this.recurrentInitializer = J(t.recurrentInitializer || this.DEFAULT_RECURRENT_INITIALIZER), this.biasInitializer = J(t.biasInitializer || this.DEFAULT_BIAS_INITIALIZER), this.kernelRegularizer = X(t.kernelRegularizer), this.recurrentRegularizer = X(t.recurrentRegularizer), this.biasRegularizer = X(t.biasRegularizer), this.kernelConstraint = rt(t.kernelConstraint), this.recurrentConstraint = rt(t.recurrentConstraint), this.biasConstraint = rt(t.biasConstraint), this.dropout = Ne([1, Ht([0, t.dropout == null ? 0 : t.dropout])]), this.recurrentDropout = Ne([
       1,
-      qt([0, t.recurrentDropout == null ? 0 : t.recurrentDropout])
+      Ht([0, t.recurrentDropout == null ? 0 : t.recurrentDropout])
     ]), this.dropoutFunc = t.dropoutFunc, this.stateSize = this.units, this.dropoutMask = null, this.recurrentDropoutMask = null;
   }
   build(t) {
@@ -10726,9 +10727,9 @@ class Cs extends In {
   constructor(t) {
     if (super(t), this.DEFAULT_ACTIVATION = "tanh", this.DEFAULT_RECURRENT_ACTIVATION = "hardSigmoid", this.DEFAULT_KERNEL_INITIALIZER = "glorotNormal", this.DEFAULT_RECURRENT_INITIALIZER = "orthogonal", this.DEFAULT_BIAS_INITIALIZER = "zeros", t.resetAfter)
       throw new d("GRUCell does not support reset_after parameter set to true.");
-    this.units = t.units, ot(this.units, "units"), this.activation = Qt(t.activation === void 0 ? this.DEFAULT_ACTIVATION : t.activation), this.recurrentActivation = Qt(t.recurrentActivation === void 0 ? this.DEFAULT_RECURRENT_ACTIVATION : t.recurrentActivation), this.useBias = t.useBias == null ? !0 : t.useBias, this.kernelInitializer = J(t.kernelInitializer || this.DEFAULT_KERNEL_INITIALIZER), this.recurrentInitializer = J(t.recurrentInitializer || this.DEFAULT_RECURRENT_INITIALIZER), this.biasInitializer = J(t.biasInitializer || this.DEFAULT_BIAS_INITIALIZER), this.kernelRegularizer = X(t.kernelRegularizer), this.recurrentRegularizer = X(t.recurrentRegularizer), this.biasRegularizer = X(t.biasRegularizer), this.kernelConstraint = rt(t.kernelConstraint), this.recurrentConstraint = rt(t.recurrentConstraint), this.biasConstraint = rt(t.biasConstraint), this.dropout = ve([1, qt([0, t.dropout == null ? 0 : t.dropout])]), this.recurrentDropout = ve([
+    this.units = t.units, ot(this.units, "units"), this.activation = Qt(t.activation === void 0 ? this.DEFAULT_ACTIVATION : t.activation), this.recurrentActivation = Qt(t.recurrentActivation === void 0 ? this.DEFAULT_RECURRENT_ACTIVATION : t.recurrentActivation), this.useBias = t.useBias == null ? !0 : t.useBias, this.kernelInitializer = J(t.kernelInitializer || this.DEFAULT_KERNEL_INITIALIZER), this.recurrentInitializer = J(t.recurrentInitializer || this.DEFAULT_RECURRENT_INITIALIZER), this.biasInitializer = J(t.biasInitializer || this.DEFAULT_BIAS_INITIALIZER), this.kernelRegularizer = X(t.kernelRegularizer), this.recurrentRegularizer = X(t.recurrentRegularizer), this.biasRegularizer = X(t.biasRegularizer), this.kernelConstraint = rt(t.kernelConstraint), this.recurrentConstraint = rt(t.recurrentConstraint), this.biasConstraint = rt(t.biasConstraint), this.dropout = Ne([1, Ht([0, t.dropout == null ? 0 : t.dropout])]), this.recurrentDropout = Ne([
       1,
-      qt([0, t.recurrentDropout == null ? 0 : t.recurrentDropout])
+      Ht([0, t.recurrentDropout == null ? 0 : t.recurrentDropout])
     ]), this.dropoutFunc = t.dropoutFunc, this.implementation = t.implementation, this.stateSize = this.units, this.dropoutMask = null, this.recurrentDropoutMask = null;
   }
   build(t) {
@@ -10760,10 +10761,10 @@ class Cs extends In {
       0 < this.dropout && this.dropout < 1 && (t = w(t, r[0]));
       let c = St(t, this.kernel.read());
       this.useBias && (c = zt(c, this.bias.read())), 0 < this.recurrentDropout && this.recurrentDropout < 1 && (i = w(i, a[0]));
-      const h = this.recurrentKernel.read(), [p, f] = Kt(h, [2 * this.units, this.units], h.rank - 1), g = St(i, p), [b, m, N] = Kt(c, 3, c.rank - 1), [y, C] = Kt(g, 2, g.rank - 1);
+      const h = this.recurrentKernel.read(), [p, f] = Kt(h, [2 * this.units, this.units], h.rank - 1), g = St(i, p), [b, m, v] = Kt(c, 3, c.rank - 1), [y, C] = Kt(g, 2, g.rank - 1);
       o = this.recurrentActivation.apply($(b, y)), l = this.recurrentActivation.apply($(m, C));
-      const v = St(w(l, i), f);
-      u = this.activation.apply($(N, v));
+      const N = St(w(l, i), f);
+      u = this.activation.apply($(v, N));
       const I = $(w(o, i), w($(1, pt(o)), u));
       return [I, I];
     });
@@ -10814,9 +10815,9 @@ ma.className = "GRU";
 S(ma);
 class Dn extends In {
   constructor(t) {
-    super(t), this.DEFAULT_ACTIVATION = "tanh", this.DEFAULT_RECURRENT_ACTIVATION = "hardSigmoid", this.DEFAULT_KERNEL_INITIALIZER = "glorotNormal", this.DEFAULT_RECURRENT_INITIALIZER = "orthogonal", this.DEFAULT_BIAS_INITIALIZER = "zeros", this.units = t.units, ot(this.units, "units"), this.activation = Qt(t.activation === void 0 ? this.DEFAULT_ACTIVATION : t.activation), this.recurrentActivation = Qt(t.recurrentActivation === void 0 ? this.DEFAULT_RECURRENT_ACTIVATION : t.recurrentActivation), this.useBias = t.useBias == null ? !0 : t.useBias, this.kernelInitializer = J(t.kernelInitializer || this.DEFAULT_KERNEL_INITIALIZER), this.recurrentInitializer = J(t.recurrentInitializer || this.DEFAULT_RECURRENT_INITIALIZER), this.biasInitializer = J(t.biasInitializer || this.DEFAULT_BIAS_INITIALIZER), this.unitForgetBias = t.unitForgetBias, this.kernelRegularizer = X(t.kernelRegularizer), this.recurrentRegularizer = X(t.recurrentRegularizer), this.biasRegularizer = X(t.biasRegularizer), this.kernelConstraint = rt(t.kernelConstraint), this.recurrentConstraint = rt(t.recurrentConstraint), this.biasConstraint = rt(t.biasConstraint), this.dropout = ve([1, qt([0, t.dropout == null ? 0 : t.dropout])]), this.recurrentDropout = ve([
+    super(t), this.DEFAULT_ACTIVATION = "tanh", this.DEFAULT_RECURRENT_ACTIVATION = "hardSigmoid", this.DEFAULT_KERNEL_INITIALIZER = "glorotNormal", this.DEFAULT_RECURRENT_INITIALIZER = "orthogonal", this.DEFAULT_BIAS_INITIALIZER = "zeros", this.units = t.units, ot(this.units, "units"), this.activation = Qt(t.activation === void 0 ? this.DEFAULT_ACTIVATION : t.activation), this.recurrentActivation = Qt(t.recurrentActivation === void 0 ? this.DEFAULT_RECURRENT_ACTIVATION : t.recurrentActivation), this.useBias = t.useBias == null ? !0 : t.useBias, this.kernelInitializer = J(t.kernelInitializer || this.DEFAULT_KERNEL_INITIALIZER), this.recurrentInitializer = J(t.recurrentInitializer || this.DEFAULT_RECURRENT_INITIALIZER), this.biasInitializer = J(t.biasInitializer || this.DEFAULT_BIAS_INITIALIZER), this.unitForgetBias = t.unitForgetBias, this.kernelRegularizer = X(t.kernelRegularizer), this.recurrentRegularizer = X(t.recurrentRegularizer), this.biasRegularizer = X(t.biasRegularizer), this.kernelConstraint = rt(t.kernelConstraint), this.recurrentConstraint = rt(t.recurrentConstraint), this.biasConstraint = rt(t.biasConstraint), this.dropout = Ne([1, Ht([0, t.dropout == null ? 0 : t.dropout])]), this.recurrentDropout = Ne([
       1,
-      qt([0, t.recurrentDropout == null ? 0 : t.recurrentDropout])
+      Ht([0, t.recurrentDropout == null ? 0 : t.recurrentDropout])
     ]), this.dropoutFunc = t.dropoutFunc, this.implementation = t.implementation, this.stateSize = [this.units, this.units], this.dropoutMask = null, this.recurrentDropoutMask = null;
   }
   build(t) {
@@ -10869,8 +10870,8 @@ class Dn extends In {
       0 < this.recurrentDropout && this.recurrentDropout < 1 && (i = w(i, o[0])), p = $(p, St(i, this.recurrentKernel.read())), this.useBias && (p = zt(p, this.bias.read()));
       const [f, g, b, m] = Kt(p, 4, p.rank - 1);
       l = this.recurrentActivation.apply(f), u = this.recurrentActivation.apply(g), c = $(w(u, r), w(l, this.activation.apply(b))), h = this.recurrentActivation.apply(m);
-      const N = w(h, this.activation.apply(c));
-      return [N, N, c];
+      const v = w(h, this.activation.apply(c));
+      return [v, v, c];
     });
   }
   getConfig() {
@@ -11020,7 +11021,7 @@ class Is extends In {
 Is.className = "StackedRNNCells";
 S(Is);
 function te(s) {
-  const { ones: t, rate: e, training: n = !1, count: i = 1, dropoutFunc: r } = s, a = () => r != null ? r(t(), e) : Hi(t(), e), o = () => Ke(a, t, n);
+  const { ones: t, rate: e, training: n = !1, count: i = 1, dropoutFunc: r } = s, a = () => r != null ? r(t(), e) : Ki(t(), e), o = () => Ve(a, t, n);
   return !i || i <= 1 ? Bt(o().clone()) : Array(i).fill(void 0).map(o).map((u) => Bt(u.clone()));
 }
 /**
@@ -11032,7 +11033,7 @@ function te(s) {
  * https://opensource.org/licenses/MIT.
  * =============================================================================
  */
-var Jf = function(s, t) {
+var Xf = function(s, t) {
   var e = {};
   for (var n in s) Object.prototype.hasOwnProperty.call(s, n) && t.indexOf(n) < 0 && (e[n] = s[n]);
   if (s != null && typeof Object.getOwnPropertySymbols == "function")
@@ -11121,7 +11122,7 @@ class Ds extends Dn {
         l = new (e = class extends kt {
           apply(p, f) {
             const g = u.apply([c]), b = pe([c]), m = u.apply([c * 2]);
-            return ns([g, b, m]);
+            return ts([g, b, m]);
           }
         }, /** @nocollapse */
         e.className = "CustomInit", e)();
@@ -11153,17 +11154,17 @@ class Ds extends Dn {
         dropoutFunc: this.dropoutFunc
       }));
       const g = this.recurrentDropoutMask;
-      let b = u(r, g, 0), m = u(r, g, 1), N = u(r, g, 2), y = u(r, g, 3);
-      const C = 3, [v, I, z, _] = Kt(this.kernel.read(), o, C), [T, E, R, q] = this.useBias ? Kt(this.bias.read(), o) : [null, null, null, null];
-      c = this.inputConv(c, v, T, this.padding), h = this.inputConv(h, I, E, this.padding), p = this.inputConv(p, z, R, this.padding), f = this.inputConv(f, _, q, this.padding);
+      let b = u(r, g, 0), m = u(r, g, 1), v = u(r, g, 2), y = u(r, g, 3);
+      const C = 3, [N, I, z, _] = Kt(this.kernel.read(), o, C), [T, E, R, q] = this.useBias ? Kt(this.bias.read(), o) : [null, null, null, null];
+      c = this.inputConv(c, N, T, this.padding), h = this.inputConv(h, I, E, this.padding), p = this.inputConv(p, z, R, this.padding), f = this.inputConv(f, _, q, this.padding);
       const [bt, ie, re, xt] = Kt(this.recurrentKernel.read(), o, C);
-      b = this.recurrentConv(b, bt), m = this.recurrentConv(m, ie), N = this.recurrentConv(N, re), y = this.recurrentConv(y, xt);
-      const Tt = this.recurrentActivation.apply($(c, b)), me = this.recurrentActivation.apply($(h, m)), ze = $(w(me, a), w(Tt, this.activation.apply($(p, N)))), Ts = w(this.recurrentActivation.apply($(f, y)), this.activation.apply(ze));
+      b = this.recurrentConv(b, bt), m = this.recurrentConv(m, ie), v = this.recurrentConv(v, re), y = this.recurrentConv(y, xt);
+      const Tt = this.recurrentActivation.apply($(c, b)), me = this.recurrentActivation.apply($(h, m)), ze = $(w(me, a), w(Tt, this.activation.apply($(p, v)))), Ts = w(this.recurrentActivation.apply($(f, y)), this.activation.apply(ze));
       return [Ts, Ts, ze];
     });
   }
   getConfig() {
-    const t = super.getConfig(), { units: e } = t, n = Jf(t, ["units"]), i = {
+    const t = super.getConfig(), { units: e } = t, n = Xf(t, ["units"]), i = {
       filters: this.filters,
       kernelSize: this.kernelSize,
       padding: this.padding,
@@ -11222,7 +11223,7 @@ class zs extends W {
       const n = O(t);
       if (0 < this.rate && this.rate < 1) {
         const i = e.training == null ? !1 : e.training, r = this.getNoiseShape(n);
-        return Ke(() => Hi(n, this.rate, r, this.seed), () => n, i);
+        return Ve(() => Ki(n, this.rate, r, this.seed), () => n, i);
       }
       return t;
     });
@@ -11273,7 +11274,7 @@ class ka extends W {
   call(t, e) {
     return x(() => {
       this.invokeCallHook(t, e);
-      const n = O(t), i = Ki(this.activation.getClassName());
+      const n = O(t), i = ji(this.activation.getClassName());
       let r;
       return i != null ? r = St(n, this.kernel.read(), i, this.bias ? this.bias.read() : null) : (r = St(n, this.kernel.read()), this.bias != null && (r = zt(r, this.bias.read())), this.activation != null && (r = this.activation.apply(r))), r;
     });
@@ -11317,7 +11318,7 @@ class xa extends W {
           i.push(r);
         i.push(1), n = j(n, i);
       }
-      return _u(n);
+      return Mu(n);
     });
   }
   getConfig() {
@@ -11329,7 +11330,7 @@ class xa extends W {
 }
 xa.className = "Flatten";
 S(xa);
-class va extends W {
+class Na extends W {
   constructor(t) {
     super(t), this.supportsMasking = !0, this.activation = Qt(t.activation);
   }
@@ -11345,9 +11346,9 @@ class va extends W {
     return Object.assign(t, e), t;
   }
 }
-va.className = "Activation";
-S(va);
-class Na extends W {
+Na.className = "Activation";
+S(Na);
+class va extends W {
   constructor(t) {
     super(t), this.n = t.n, this.inputSpec = [{ ndim: 2 }];
   }
@@ -11355,7 +11356,7 @@ class Na extends W {
     return [t[0], this.n, t[1]];
   }
   call(t, e) {
-    return x(() => (t = O(t), Bu(t, this.n)));
+    return x(() => (t = O(t), Ou(t, this.n)));
   }
   getConfig() {
     const t = {
@@ -11364,8 +11365,8 @@ class Na extends W {
     return Object.assign(t, e), t;
   }
 }
-Na.className = "RepeatVector";
-S(Na);
+va.className = "RepeatVector";
+S(va);
 class Sa extends W {
   constructor(t) {
     super(t), this.targetShape = t.targetShape;
@@ -11635,7 +11636,7 @@ class fe extends W {
       if (t = t, this.reshapeRequired) {
         const n = [], i = t.map((r) => r.rank);
         if (i.indexOf(null) === -1) {
-          const r = qt(i);
+          const r = Ht(i);
           for (let a of t) {
             const o = a.rank;
             for (let l = 0; l < r - o; ++l)
@@ -11699,10 +11700,10 @@ class fe extends W {
         throw new d(`The Array 'inputs' and 'mask' are expected to have the same length, but have different lengths (${t.length} vs ${e.length})`);
       if (e.every((i) => i == null))
         return null;
-      e = e.map((i) => i == null ? i : ue(i, 0));
+      e = e.map((i) => i == null ? i : ce(i, 0));
       let n = e[0];
       for (let i = 1; i < e.length - 1; ++i)
-        n = Pe(n, e[i]);
+        n = je(n, e[i]);
       return n;
     });
   }
@@ -11775,7 +11776,7 @@ class Ea extends fe {
     return x(() => {
       let e = t[0];
       for (let n = 1; n < t.length; ++n)
-        e = ji(e, t[n]);
+        e = Zi(e, t[n]);
       return e;
     });
   }
@@ -11814,7 +11815,7 @@ class La extends fe {
       throw new d("A `Concatenate` layer requires inputs with matching shapes except for the concat axis. Got input shapes: " + JSON.stringify(t));
   }
   mergeFunction(t) {
-    return x(() => ns(t, this.axis));
+    return x(() => ts(t, this.axis));
   }
   computeOutputShape(t) {
     if (!(Array.isArray(t) && Array.isArray(t[0])))
@@ -11849,9 +11850,9 @@ class La extends fe {
         return null;
       const i = [];
       for (let a = 0; a < t.length; ++a)
-        e[a] == null ? i.push(L(Dt(t[a]), "bool")) : e[a].rank < t[a].rank ? i.push(ue(e[a], -1)) : i.push(e[a]);
+        e[a] == null ? i.push(L(Dt(t[a]), "bool")) : e[a].rank < t[a].rank ? i.push(ce(e[a], -1)) : i.push(e[a]);
       const r = is(i, this.axis);
-      return Ju(r, -1, !1);
+      return Xu(r, -1, !1);
     });
   }
   getConfig() {
@@ -11868,7 +11869,7 @@ function $e(s, t) {
     s += t;
   return s;
 }
-function Xf(s, t, e) {
+function Yf(s, t, e) {
   if (s.shape.length > 3 || t.shape.length > 3)
     throw new G("batchDot is not implemented for tensors of 4D or higher rank yet");
   if (k(s.shape.length >= 2, () => `batchDot requires the rank of x to be >= 2, but got ${s.shape.length}`), k(s.shape.length >= 2, () => `batchDot requires the rank of y to be >= 2, but got ${t.shape.length}`), typeof e == "number" && (e = [e, e]), s.dtype === "complex64" || t.dtype === "complex64")
@@ -11905,9 +11906,9 @@ function Xf(s, t, e) {
       const u = [];
       for (let c = l; c < l + a; ++c)
         u.push(c);
-      o = ts(o, u);
+      o = ns(o, u);
     }
-    return o.shape.length === 1 && (o = ue(o, 1)), o;
+    return o.shape.length === 1 && (o = ce(o, 1)), o;
   });
 }
 class Fa extends fe {
@@ -11930,7 +11931,7 @@ class Fa extends fe {
     return Array.isArray(this.axes) ? i = this.axes.map((r, a) => $e(r, t[a].shape.length)) : i = [
       $e(this.axes, e.shape.length),
       $e(this.axes, n.shape.length)
-    ], this.normalize && (e = pn(e, i[0]), n = pn(n, i[1])), Xf(e, n, i);
+    ], this.normalize && (e = pn(e, i[0]), n = pn(n, i[1])), Yf(e, n, i);
   }
   interpretAxes(t, e) {
     let n;
@@ -11986,7 +11987,7 @@ class Ma extends W {
     return x(() => {
       this.invokeCallHook(t, e);
       const n = O(t);
-      return Ke(() => $(bn(n.shape, 0, this.stddev), n), () => n, e.training || !1);
+      return Ve(() => $(bn(n.shape, 0, this.stddev), n), () => n, e.training || !1);
     });
   }
 }
@@ -12007,7 +12008,7 @@ class Oa extends W {
     return x(() => {
       this.invokeCallHook(t, e);
       const n = O(t);
-      return this.rate > 0 && this.rate < 1 ? Ke(() => {
+      return this.rate > 0 && this.rate < 1 ? Ve(() => {
         const r = Math.sqrt(this.rate / (1 - this.rate));
         return w(n, bn(n.shape, 1, r));
       }, () => n, e.training || !1) : n;
@@ -12034,9 +12035,9 @@ class Ra extends W {
     return x(() => {
       if (this.rate < 1 && this.rate > 0) {
         const n = this._getNoiseShape(t);
-        return Ke(() => {
+        return Ve(() => {
           const r = O(t), o = -1.6732632423543772 * 1.0507009873554805;
-          let l = Ue(wn(n), this.rate);
+          let l = Ke(wn(n), this.rate);
           l = Lt(l, "float32");
           const u = ((1 - this.rate) * (1 + this.rate * o ** 2)) ** -0.5, c = -u * o * this.rate, h = $(w(r, l), w($(l, -1), o));
           return $(w(h, u), c);
@@ -12060,22 +12061,22 @@ S(Ra);
 function _e(s, t, e, n, i, r = 1e-3) {
   let a;
   if (s.rank === 2)
-    a = dc(s, t, e, n, i, r);
+    a = fc(s, t, e, n, i, r);
   else if (s.rank === 3)
-    a = mc(s, t, e, n, i, r);
+    a = gc(s, t, e, n, i, r);
   else if (s.rank === 4)
-    a = bc(s, t, e, n, i, r);
+    a = yc(s, t, e, n, i, r);
   else
     throw new G(`batchNormalization is not implemented for array of rank ${s.rank} yet`);
   return a;
 }
-function Yf(s, t, e, n, i = 1e-3) {
+function Qf(s, t, e, n, i = 1e-3) {
   return x(() => {
     const r = rs(s, n), a = r.mean, o = r.variance;
     return [_e(s, a, o, e, t, i), a, o];
   });
 }
-function Qf(s, t, e, n, i = 1e-3) {
+function tm(s, t, e, n, i = 1e-3) {
   return x(() => {
     const r = rs(s, n), a = r.mean, o = r.variance, l = [];
     for (const g of It(0, s.rank))
@@ -12084,8 +12085,8 @@ function Qf(s, t, e, n, i = 1e-3) {
     return [_e(s, u, c, p, h, i), a, o];
   });
 }
-function tm(s, t, e, n, i = 1e-3) {
-  return Ft(n.slice().sort(), It(0, s.rank - 1)) ? Yf(s, t, e, n, i) : Qf(s, t, e, n, i);
+function em(s, t, e, n, i = 1e-3) {
+  return Ft(n.slice().sort(), It(0, s.rank - 1)) ? Qf(s, t, e, n, i) : tm(s, t, e, n, i);
 }
 class _a extends W {
   constructor(t) {
@@ -12104,22 +12105,22 @@ class _a extends W {
     return x(() => {
       const n = e.training == null ? !1 : e.training, i = O(t), r = i.shape, a = r.length, o = It(0, a), l = this.axis >= 0 ? this.axis : this.axis + a;
       o.splice(l, 1);
-      const u = ce(1, a);
+      const u = ue(1, a);
       u[l] = r[l];
       const c = o.slice();
       c.sort();
       const h = !Ft(c, It(0, a).slice(0, a - 1)), p = () => {
         if (h) {
-          const y = A(this.movingMean.read(), u), C = A(this.movingVariance.read(), u), v = this.center ? A(this.beta.read(), u) : null, I = this.scale ? A(this.gamma.read(), u) : null;
-          return _e(i, y, C, v, I, this.epsilon);
+          const y = A(this.movingMean.read(), u), C = A(this.movingVariance.read(), u), N = this.center ? A(this.beta.read(), u) : null, I = this.scale ? A(this.gamma.read(), u) : null;
+          return _e(i, y, C, N, I, this.epsilon);
         } else
           return _e(i, this.movingMean.read(), this.movingVariance.read(), this.beta == null ? null : this.beta.read(), this.gamma == null ? null : this.gamma.read(), this.epsilon);
       };
       if (!n)
         return p();
-      const [f, g, b] = tm(i, this.gamma.read(), this.beta.read(), o, this.epsilon), m = (y, C, v) => {
+      const [f, g, b] = em(i, this.gamma.read(), this.beta.read(), o, this.epsilon), m = (y, C, N) => {
         x(() => {
-          const I = 1 - v, z = y.read(), _ = w(V(z, C), I);
+          const I = 1 - N, z = y.read(), _ = w(V(z, C), I);
           y.write(V(z, _));
         });
       };
@@ -12180,7 +12181,7 @@ class Ba extends W {
     const n = O(t), i = n.shape, r = i.length;
     return x(() => {
       let { mean: o, variance: l } = rs(n, this.axis, !0);
-      const u = ce(1, r);
+      const u = ue(1, r);
       for (const b of this.axis)
         u[b] = i[b];
       const c = (b) => b != null && b.shape.length !== r ? A(b, u) : b;
@@ -12216,7 +12217,7 @@ S(Ba);
  * https://opensource.org/licenses/MIT.
  * =============================================================================
  */
-function em(s, t, e) {
+function nm(s, t, e) {
   return x(() => {
     if (s.rank !== 4)
       throw new d(`temporalPadding expects input tensor to be 4-D, but received a ${s.rank}-D tensor.`);
@@ -12257,7 +12258,7 @@ class Wa extends W {
     return this.dataFormat === "channelsFirst" ? (t[2] != null && t[2] >= 0 ? e = t[2] + this.padding[0][0] + this.padding[0][1] : e = null, t[3] != null && t[3] >= 0 ? n = t[3] + this.padding[1][0] + this.padding[1][1] : n = null, [t[0], t[1], e, n]) : (t[1] != null && t[1] >= 0 ? e = t[1] + this.padding[0][0] + this.padding[0][1] : e = null, t[2] != null && t[2] >= 0 ? n = t[2] + this.padding[1][0] + this.padding[1][1] : n = null, [t[0], e, n, t[3]]);
   }
   call(t, e) {
-    return x(() => em(O(t), this.padding, this.dataFormat));
+    return x(() => nm(O(t), this.padding, this.dataFormat));
   }
   getConfig() {
     const t = {
@@ -12280,10 +12281,10 @@ S(Wa);
  */
 function zn(s, t, e, n, i, r) {
   return x(() => {
-    et(i), qi(r), gt(n), e == null && (e = [1, 1]), n == null && (n = "valid"), i == null && (i = ne()), r == null && (r = "max"), s = Ss(s, i);
+    et(i), Hi(r), gt(n), e == null && (e = [1, 1]), n == null && (n = "valid"), i == null && (i = ne()), r == null && (r = "max"), s = Ss(s, i);
     let a;
     const o = n === "same" ? "same" : "valid";
-    return r === "max" ? a = Hc(s, t, e, o) : a = ic(
+    return r === "max" ? a = qc(s, t, e, o) : a = rc(
       // TODO(cais): Rank check?
       s,
       t,
@@ -12294,10 +12295,10 @@ function zn(s, t, e, n, i, r) {
 }
 function Ga(s, t, e, n, i, r) {
   return x(() => {
-    et(i), qi(r), gt(n), e == null && (e = [1, 1, 1]), n == null && (n = "valid"), i == null && (i = ne()), r == null && (r = "max"), s = ia(s, i);
+    et(i), Hi(r), gt(n), e == null && (e = [1, 1, 1]), n == null && (n = "valid"), i == null && (i = ne()), r == null && (r = "max"), s = ia(s, i);
     let a;
     const o = n === "same" ? "same" : "valid";
-    return r === "max" ? a = Zc(s, t, e, o) : a = ac(s, t, e, o), i === "channelsFirst" && (a = j(a, [0, 4, 1, 2, 3])), a;
+    return r === "max" ? a = Jc(s, t, e, o) : a = oc(s, t, e, o), i === "channelsFirst" && (a = j(a, [0, 4, 1, 2, 3])), a;
   });
 }
 class Pa extends W {
@@ -12333,7 +12334,7 @@ class Pa extends W {
     return x(() => {
       this.invokeCallHook(t, e), t = yn(O(t), 2);
       const n = this.poolingFunction(O(t), [this.poolSize[0], 1], [this.strides[0], 1], this.padding, "channelsLast");
-      return ts(n, [2]);
+      return ns(n, [2]);
     });
   }
   getConfig() {
@@ -12496,7 +12497,7 @@ class Qa extends Xa {
   call(t, e) {
     return x(() => {
       const n = O(t);
-      return Ne(n, 1);
+      return ve(n, 1);
     });
   }
 }
@@ -12531,7 +12532,7 @@ class no extends to {
   call(t, e) {
     return x(() => {
       const n = O(t);
-      return this.dataFormat === "channelsLast" ? Ne(n, [1, 2]) : Ne(n, [2, 3]);
+      return this.dataFormat === "channelsLast" ? ve(n, [1, 2]) : ve(n, [2, 3]);
     });
   }
 }
@@ -12634,17 +12635,17 @@ class io extends so {
 }
 io.className = "TimeDistributed";
 S(io);
-function nm(s) {
-  Zn(Wu, "BidirectionalMergeMode", s);
+function sm(s) {
+  Zn(Ru, "BidirectionalMergeMode", s);
 }
-const sm = "concat";
+const im = "concat";
 class ro extends so {
   constructor(t) {
     super(t);
     const e = t.layer.getConfig(), n = {};
     n.className = t.layer.getClassName(), n.config = e, this.forwardLayer = Wt(n), e.goBackwards = e.goBackwards !== !0;
     const i = {};
-    if (i.className = t.layer.getClassName(), i.config = e, this.backwardLayer = Wt(i), this.forwardLayer.name = "forward_" + this.forwardLayer.name, this.backwardLayer.name = "backward_" + this.backwardLayer.name, this.mergeMode = t.mergeMode === void 0 ? sm : t.mergeMode, nm(this.mergeMode), t.weights)
+    if (i.className = t.layer.getClassName(), i.config = e, this.backwardLayer = Wt(i), this.forwardLayer.name = "forward_" + this.forwardLayer.name, this.backwardLayer.name = "backward_" + this.backwardLayer.name, this.mergeMode = t.mergeMode === void 0 ? im : t.mergeMode, sm(this.mergeMode), t.weights)
       throw new G("weights support is not implemented for Bidirectional layer yet.");
     this._stateful = t.layer.stateful, this.returnSequences = t.layer.returnSequences, this.returnState = t.layer.returnState, this.supportsMasking = !0, this._trainable = !0, this.inputSpec = t.layer.inputSpec, this.numConstants = null;
   }
@@ -12709,7 +12710,7 @@ class ro extends so {
       let a;
       this.returnState && (Array.isArray(i) && (a = i.slice(1).concat(r.slice(1))), i = i[0], r = r[0]), this.returnSequences && (r = on(r, 1));
       let o;
-      return this.mergeMode === "concat" ? o = ns([i, r]) : this.mergeMode === "sum" ? o = $(i, r) : this.mergeMode === "ave" ? o = w(0.5, $(i, r)) : this.mergeMode === "mul" ? o = w(i, r) : this.mergeMode == null && (o = [i, r]), this.returnState ? this.mergeMode == null ? o.concat(a) : [o].concat(a) : o;
+      return this.mergeMode === "concat" ? o = ts([i, r]) : this.mergeMode === "sum" ? o = $(i, r) : this.mergeMode === "ave" ? o = w(0.5, $(i, r)) : this.mergeMode === "mul" ? o = w(i, r) : this.mergeMode == null && (o = [i, r]), this.returnState ? this.mergeMode == null ? o.concat(a) : [o].concat(a) : o;
     });
   }
   resetStates(t) {
@@ -12793,7 +12794,7 @@ S(ao);
  * https://opensource.org/licenses/MIT.
  * =============================================================================
  */
-const { resizeBilinear: im, cropAndResize: rm } = _t;
+const { resizeBilinear: rm, cropAndResize: am } = _t;
 class oo extends W {
   constructor(t) {
     super(t), this.height = t.height, this.width = t.width;
@@ -12805,13 +12806,13 @@ class oo extends W {
       t.rank === 3 ? (c = !0, u = kn([t])) : u = t;
       for (let I = 0; I < u.shape[0]; I++)
         m.push(b);
-      const N = Ku(m, [m.length, 4]), y = Hu(0, m.length, 1, "int32"), v = rm(u, N, y, [i, r], "nearest");
-      return c ? Lt(O(en(v)), l) : Lt(v, l);
+      const v = Hu(m, [m.length, 4]), y = qu(0, m.length, 1, "int32"), N = am(u, v, y, [i, r], "nearest");
+      return c ? Lt(O(nn(N)), l) : Lt(N, l);
     });
   }
   upsize(t, e, n, i) {
     return x(() => {
-      const r = im(t, [e, n]);
+      const r = rm(t, [e, n]);
       return Lt(r, i);
     });
   }
@@ -12848,12 +12849,12 @@ S(oo);
  * https://opensource.org/licenses/MIT.
  * =============================================================================
  */
-function am(s, t, e, n) {
+function om(s, t, e, n) {
   let i = O(s);
   if (i.dtype !== "int32" && (i = Lt(i, "int32")), t === "int")
     return i;
   const r = i.shape;
-  if (i.rank === 0 && (i = ue(i, -1)), t === "oneHot" && i.shape[i.shape.length - 1] !== 1 && (i = ue(i, -1)), i.rank > 2)
+  if (i.rank === 0 && (i = ce(i, -1)), t === "oneHot" && i.shape[i.shape.length - 1] !== 1 && (i = ce(i, -1)), i.rank > 2)
     throw new d(`When outputMode is not int, maximum output rank is 2 Received outputMode ${t} and input shape ${r} which would result in output rank ${i.rank}.`);
   const a = ["multiHot", "oneHot"].includes(t), o = i;
   let l;
@@ -12896,10 +12897,10 @@ class lo extends W {
               Received countWeights=${e.countWeights}`);
         n = O(e.countWeights);
       }
-      const i = Ne(t), r = qu(t), a = Gt(this.numTokens, i).bufferSync().get(0), o = Ue(r, 0).bufferSync().get(0);
+      const i = ve(t), r = Zu(t), a = Gt(this.numTokens, i).bufferSync().get(0), o = Ke(r, 0).bufferSync().get(0);
       if (!(a && o))
         throw new d(`Input values must be between 0 < values <= numTokens with numTokens=${this.numTokens}`);
-      return am(t, this.outputMode, this.numTokens, n);
+      return om(t, this.outputMode, this.numTokens, n);
     });
   }
 }
@@ -12914,7 +12915,7 @@ S(lo);
  * https://opensource.org/licenses/MIT.
  * =============================================================================
  */
-const om = ["bilinear", "nearest"], di = new Set(om);
+const lm = ["bilinear", "nearest"], di = new Set(lm);
 class uo extends W {
   constructor(t) {
     if (super(t), this.height = t.height, this.width = t.width, t.interpolation)
@@ -13002,7 +13003,7 @@ ho.className = "BaseRandomLayer";
  * https://opensource.org/licenses/MIT.
  * =============================================================================
  */
-const lm = ["bilinear", "nearest"], fi = new Set(lm);
+const um = ["bilinear", "nearest"], fi = new Set(um);
 class po extends ho {
   constructor(t) {
     super(t);
@@ -13061,50 +13062,32 @@ class po extends ho {
 }
 po.className = "RandomWidth";
 S(po);
-class Om {
+class _m extends Pu {
   vocabSize;
   embedDim;
-  tiedWeights;
   initializer;
-  constructor(t, e) {
-    this.vocabSize = t.vocabSize, this.embedDim = t.embedDim, this.initializer = Yd({
+  WEIGHTS;
+  constructor(t, e, n) {
+    super(t, n), this.WEIGHTS = e, this.vocabSize = t.gpt.vocabSize, this.embedDim = t.gpt.nEmbed, this.initializer = Qd({
       mean: 0,
       stddev: 0.02
-    }), this.tiedWeights = Ji(
-      this.initializer.apply([this.vocabSize, this.embedDim]),
-      !0,
-      e || "tied_embedding"
-    );
-  }
-  get variables() {
-    return [this.tiedWeights];
+    }), this.addVariable(this.WEIGHTS, Ji(this.initializer.apply([this.vocabSize, this.embedDim]), !0));
   }
   embed(t) {
-    return Qi(this.tiedWeights, t, 0);
+    return Qi(this.getVariable(this.WEIGHTS), t, 0);
   }
   project(t) {
-    return St(t, this.tiedWeights.transpose());
+    return St(t, this.getVariable(this.WEIGHTS).transpose());
   }
-  getWeights() {
-    return [this.tiedWeights];
-  }
-  setWeights(t) {
-    this.tiedWeights.assign(t[0]);
-  }
-  getConfig() {
-    return {
-      vocabSize: this.vocabSize,
-      embedDim: this.embedDim
-    };
-  }
-  dispose() {
-    this.tiedWeights.dispose();
+  // Dummy, should not be used.
+  forward(t, e) {
+    return this.project(e);
   }
 }
 export {
   zs as D,
   Ia as E,
-  Om as T,
+  _m as T,
   sr as p,
-  Yd as r
+  Qd as r
 };