Spaces:
Running
Running
Download nlrt.js from thelamapi/Next-Federation: direct link, hf CLI and curl.
- Browser
- Download file 8.37 kB
-
https://huggingface.co/spaces/thelamapi/Next-Federation/resolve/main/nlrt.js
- Command line
-
hf download hf://spaces/thelamapi/Next-Federation/nlrt.js
-
curl -L -o nlrt.js https://huggingface.co/spaces/thelamapi/Next-Federation/resolve/main/nlrt.js
8.37 kB
| /* nlrt.js: browser and Node twin of nlrt.py. Batch size 1, float64 math. */ | |
| (function (root, factory) { | |
| if (typeof module === "object" && module.exports) module.exports = factory(); | |
| else root.NLRT = factory(); | |
| })(typeof self !== "undefined" ? self : this, function () { | |
| "use strict"; | |
| function b64d(s) { | |
| let bin; | |
| if (typeof atob === "function") bin = atob(s); | |
| else bin = Buffer.from(s, "base64").toString("binary"); | |
| const bytes = new Uint8Array(bin.length); | |
| for (let i = 0; i < bin.length; i++) bytes[i] = bin.charCodeAt(i); | |
| return new Float32Array(bytes.buffer); | |
| } | |
| function decode(spec) { | |
| for (const name in spec.nets || {}) { | |
| for (const L of spec.nets[name]) { | |
| if (typeof L.w === "string") L.w = b64d(L.w); | |
| if (typeof L.b === "string") L.b = b64d(L.b); | |
| } | |
| } | |
| for (const name in spec.tensors || {}) { | |
| const t = spec.tensors[name]; | |
| if (typeof t.data === "string") t.data = b64d(t.data); | |
| } | |
| return spec; | |
| } | |
| async function loadModel(url) { | |
| const r = await fetch(url); | |
| if (!r.ok) throw new Error("cannot load " + url); | |
| return decode(await r.json()); | |
| } | |
| function pair(v) { return Array.isArray(v) ? v : [v, v]; } | |
| // Tensor: {shape: [D]} or {shape: [C, H, W]} or {shape: [C, L]}, data: Float64Array | |
| function T(shape, data) { | |
| const n = shape.reduce((a, b) => a * b, 1); | |
| return { shape: shape.slice(), data: data || new Float64Array(n) }; | |
| } | |
| function as3(x) { | |
| if (x.shape.length === 2) return { t: T([x.shape[0], 1, x.shape[1]], x.data), sq: true }; | |
| return { t: x, sq: false }; | |
| } | |
| function conv2d(x0, L) { | |
| const { t: x, sq } = as3(x0); | |
| const [C, H, W] = x.shape; | |
| const [O, I, KH, KW] = L.w_shape; | |
| const [sh, sw] = pair(L.stride), [ph, pw] = pair(L.pad); | |
| const OH = Math.floor((H + 2 * ph - KH) / sh) + 1; | |
| const OW = Math.floor((W + 2 * pw - KW) / sw) + 1; | |
| const out = new Float64Array(O * OH * OW); | |
| const w = L.w, b = L.b, xd = x.data; | |
| for (let o = 0; o < O; o++) { | |
| for (let oy = 0; oy < OH; oy++) { | |
| for (let ox = 0; ox < OW; ox++) { | |
| let s = b[o]; | |
| for (let c = 0; c < I; c++) { | |
| for (let ky = 0; ky < KH; ky++) { | |
| const iy = oy * sh + ky - ph; | |
| if (iy < 0 || iy >= H) continue; | |
| const wb = ((o * I + c) * KH + ky) * KW, xb = (c * H + iy) * W; | |
| for (let kx = 0; kx < KW; kx++) { | |
| const ix = ox * sw + kx - pw; | |
| if (ix < 0 || ix >= W) continue; | |
| s += w[wb + kx] * xd[xb + ix]; | |
| } | |
| } | |
| } | |
| out[(o * OH + oy) * OW + ox] = s; | |
| } | |
| } | |
| } | |
| return sq ? T([O, OW], out) : T([O, OH, OW], out); | |
| } | |
| function maxpool(x0, L) { | |
| const { t: x, sq } = as3(x0); | |
| const [C, H, W] = x.shape, [kh, kw] = pair(L.k); | |
| const OH = Math.floor(H / kh), OW = Math.floor(W / kw); | |
| const out = new Float64Array(C * OH * OW); | |
| for (let c = 0; c < C; c++) | |
| for (let oy = 0; oy < OH; oy++) | |
| for (let ox = 0; ox < OW; ox++) { | |
| let m = -Infinity; | |
| for (let i = 0; i < kh; i++) | |
| for (let j = 0; j < kw; j++) { | |
| const v = x.data[(c * H + oy * kh + i) * W + ox * kw + j]; | |
| if (v > m) m = v; | |
| } | |
| out[(c * OH + oy) * OW + ox] = m; | |
| } | |
| return sq ? T([C, OW], out) : T([C, OH, OW], out); | |
| } | |
| function linear(x, L) { | |
| const [O, I] = L.w_shape; | |
| const out = new Float64Array(O); | |
| for (let o = 0; o < O; o++) { | |
| let s = L.b[o]; | |
| const base = o * I; | |
| for (let i = 0; i < I; i++) s += L.w[base + i] * x.data[i]; | |
| out[o] = s; | |
| } | |
| return T([O], out); | |
| } | |
| function map(x, f) { | |
| const d = new Float64Array(x.data.length); | |
| for (let i = 0; i < d.length; i++) d[i] = f(x.data[i]); | |
| return T(x.shape, d); | |
| } | |
| function forward(layers, x) { | |
| if (!(x.data instanceof Float64Array)) x = T(x.shape, Float64Array.from(x.data)); | |
| for (const L of layers) { | |
| switch (L.type) { | |
| case "linear": x = linear(x, L); break; | |
| case "conv2d": x = conv2d(x, L); break; | |
| case "relu": x = map(x, v => (v > 0 ? v : 0)); break; | |
| case "tanh": x = map(x, Math.tanh); break; | |
| case "sigmoid": x = map(x, v => 1 / (1 + Math.exp(-v))); break; | |
| case "maxpool": x = maxpool(x, L); break; | |
| case "gap": { | |
| const C = x.shape[0], n = x.data.length / C, d = new Float64Array(C); | |
| for (let c = 0; c < C; c++) { let s = 0; for (let i = 0; i < n; i++) s += x.data[c * n + i]; d[c] = s / n; } | |
| x = T([C], d); break; | |
| } | |
| case "flatten": x = T([x.data.length], x.data); break; | |
| case "reshape": x = T(L.shape, x.data); break; | |
| case "upsample": { | |
| const s = L.s; | |
| if (x.shape.length === 3) { | |
| const [C, H, W] = x.shape, d = new Float64Array(C * H * s * W * s); | |
| for (let c = 0; c < C; c++) | |
| for (let y = 0; y < H * s; y++) | |
| for (let xx = 0; xx < W * s; xx++) | |
| d[(c * H * s + y) * W * s + xx] = x.data[(c * H + Math.floor(y / s)) * W + Math.floor(xx / s)]; | |
| x = T([C, H * s, W * s], d); | |
| } else { | |
| const [C, Ln] = x.shape, d = new Float64Array(C * Ln * s); | |
| for (let c = 0; c < C; c++) for (let i = 0; i < Ln * s; i++) d[c * Ln * s + i] = x.data[c * Ln + Math.floor(i / s)]; | |
| x = T([C, Ln * s], d); | |
| } | |
| break; | |
| } | |
| case "l2norm": { | |
| let s = 0; for (const v of x.data) s += v * v; | |
| const n = Math.max(Math.sqrt(s), 1e-12); | |
| x = map(x, v => v / n); break; | |
| } | |
| default: throw new Error("unknown layer " + L.type); | |
| } | |
| } | |
| return x; | |
| } | |
| function mulberry32(seed) { | |
| let a = seed >>> 0; | |
| const random = function () { | |
| a = (a + 0x6D2B79F5) >>> 0; | |
| let t = a; | |
| t = Math.imul(t ^ (t >>> 15), t | 1) >>> 0; | |
| t = (t ^ ((t + (Math.imul(t ^ (t >>> 7), t | 61) >>> 0)) >>> 0)) >>> 0; | |
| return ((t ^ (t >>> 14)) >>> 0) / 4294967296; | |
| }; | |
| return { | |
| random, | |
| uniform: (lo, hi) => lo + (hi - lo) * random(), | |
| randint: n => Math.floor(random() * n), | |
| normal: () => { const u = Math.max(random(), 1e-12), v = random(); return Math.sqrt(-2 * Math.log(u)) * Math.cos(2 * Math.PI * v); }, | |
| }; | |
| } | |
| function softmax(arr) { | |
| let m = -Infinity; for (const v of arr) if (v > m) m = v; | |
| const e = Array.from(arr, v => Math.exp(v - m)); const s = e.reduce((a, b) => a + b, 0); | |
| return e.map(v => v / s); | |
| } | |
| function argmax(arr) { let k = 0; for (let i = 1; i < arr.length; i++) if (arr[i] > arr[k]) k = i; return k; } | |
| // Deep comparison used by parity tests: numbers within tol, everything else exact. | |
| function compare(got, want, tol, path, acc) { | |
| acc = acc || { maxDiff: 0, mismatches: [] }; | |
| path = path || "$"; | |
| if (typeof want === "number") { | |
| const d = Math.abs(Number(got) - want); | |
| if (!(d <= tol * Math.max(1, Math.abs(want)))) acc.mismatches.push(path + ": got " + got + " want " + want); | |
| if (isFinite(d)) acc.maxDiff = Math.max(acc.maxDiff, d); | |
| } else if (Array.isArray(want)) { | |
| if (!got || got.length !== want.length) acc.mismatches.push(path + ": length " + (got && got.length) + " vs " + want.length); | |
| else for (let i = 0; i < want.length; i++) compare(got[i], want[i], tol, path + "[" + i + "]", acc); | |
| } else if (want && typeof want === "object") { | |
| for (const k in want) compare(got ? got[k] : undefined, want[k], tol, path + "." + k, acc); | |
| } else if (got !== want) acc.mismatches.push(path + ": got " + got + " want " + want); | |
| return acc; | |
| } | |
| function runParity(core, ctx, parity) { | |
| const results = []; | |
| let maxDiff = 0, failed = 0; | |
| for (const c of parity.cases) { | |
| const out = core.runCase(ctx, c.input); | |
| const r = compare(out, c.expected, c.tol != null ? c.tol : parity.tol); | |
| maxDiff = Math.max(maxDiff, r.maxDiff); | |
| if (r.mismatches.length) failed++; | |
| results.push({ name: c.name, maxDiff: r.maxDiff, mismatches: r.mismatches.slice(0, 5) }); | |
| } | |
| return { cases: parity.cases.length, failed, maxDiff, results }; | |
| } | |
| return { b64d, decode, loadModel, T, forward, mulberry32, softmax, argmax, compare, runParity }; | |
| }); | |