Next-Trace / nlrt.js
Lamapi's picture
Publish Space with valid short description
c07bca1 verified
Raw History Blame Contribute Delete
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 };
});