Download core.js from thelamapi/Next-Ask: direct link, hf CLI and curl.
- Browser
- Download file 4.79 kB
-
https://huggingface.co/spaces/thelamapi/Next-Ask/resolve/main/core.js
- Command line
-
hf download hf://spaces/thelamapi/Next-Ask/core.js
-
curl -L -o core.js https://huggingface.co/spaces/thelamapi/Next-Ask/resolve/main/core.js
4.79 kB
| /* Next Ask compute core: a line-by-line port of ask_core.py (no DOM). */ | |
| (function (root, factory) { | |
| if (typeof module === "object" && module.exports) module.exports = factory(); | |
| else root.Core = factory(); | |
| })(typeof self !== "undefined" ? self : this, function () { | |
| "use strict"; | |
| const ASSETS = ["model.json", "digits.json"]; | |
| function feats(pixels) { // pixels: array of 64 ints | |
| const x = new Float64Array(65); | |
| for (let i = 0; i < 64; i++) x[i] = pixels[i] / 16; | |
| x[64] = 1; return x; | |
| } | |
| function init(assets) { | |
| const d = assets["digits.json"], m = NLRT.decode(assets["model.json"]); | |
| return { | |
| hyper: m.meta.hyper, classes: 10, | |
| pool: d.pool_pixels.map(feats), poolPixels: d.pool_pixels, poolY: d.pool_y, | |
| test: d.test_pixels.map(feats), testY: d.test_y, | |
| W0: m.tensors.W, | |
| }; | |
| } | |
| function train(X, y, hyper) { | |
| const n = X.length, d = 65, C = 10, { steps, lr, l2 } = hyper; | |
| const W = new Float64Array(d * C), P = new Float64Array(n * C), G = new Float64Array(d * C); | |
| for (let s = 0; s < steps; s++) { | |
| for (let i = 0; i < n; i++) { | |
| let mx = -Infinity; | |
| for (let c = 0; c < C; c++) { | |
| let z = 0; for (let k = 0; k < d; k++) z += X[i][k] * W[k * C + c]; | |
| P[i * C + c] = z; if (z > mx) mx = z; | |
| } | |
| let sum = 0; | |
| for (let c = 0; c < C; c++) { const e = Math.exp(P[i * C + c] - mx); P[i * C + c] = e; sum += e; } | |
| for (let c = 0; c < C; c++) P[i * C + c] /= sum; | |
| P[i * C + y[i]] -= 1; | |
| } | |
| G.fill(0); | |
| for (let i = 0; i < n; i++) for (let k = 0; k < d; k++) { | |
| const xv = X[i][k]; if (xv === 0) continue; | |
| for (let c = 0; c < C; c++) G[k * C + c] += xv * P[i * C + c]; | |
| } | |
| for (let k = 0; k < d; k++) for (let c = 0; c < C; c++) { | |
| const reg = k === d - 1 ? 0 : l2; | |
| W[k * C + c] -= lr * (G[k * C + c] / n + reg * W[k * C + c]); | |
| } | |
| } | |
| return W; | |
| } | |
| function proba(W, x) { | |
| const C = 10, z = new Float64Array(C); let mx = -Infinity; | |
| for (let c = 0; c < C; c++) { let s = 0; for (let k = 0; k < 65; k++) s += x[k] * W[k * C + c]; z[c] = s; if (s > mx) mx = s; } | |
| let sum = 0; for (let c = 0; c < C; c++) { z[c] = Math.exp(z[c] - mx); sum += z[c]; } | |
| for (let c = 0; c < C; c++) z[c] /= sum; return z; | |
| } | |
| function margin(p) { | |
| let a = -1, b = -1; for (const v of p) { if (v > a) { b = a; a = v; } else if (v > b) b = v; } | |
| return a - b; | |
| } | |
| function accuracy(ctx, W) { | |
| let ok = 0; | |
| ctx.test.forEach((x, i) => { if (NLRT.argmax(proba(W, x)) === ctx.testY[i]) ok++; }); | |
| return ok / ctx.test.length; | |
| } | |
| function select(ctx, strategy, W, labeled, B, seed) { | |
| const X = ctx.pool, L = new Set(labeled), unl = []; | |
| for (let i = 0; i < X.length; i++) if (!L.has(i)) unl.push(i); | |
| if (strategy === "random") { | |
| const rng = NLRT.mulberry32(seed), arr = unl.slice(), picks = []; | |
| for (let k = 0; k < Math.min(B, arr.length); k++) { | |
| const j = k + rng.randint(arr.length - k); | |
| [arr[k], arr[j]] = [arr[j], arr[k]]; picks.push(arr[k]); | |
| } | |
| return picks; | |
| } | |
| const m = unl.map(i => margin(proba(W, X[i]))); | |
| const order = unl.map((_, k) => k).sort((a, b) => (m[a] - m[b]) || (unl[a] - unl[b])); | |
| if (strategy === "uncertainty") return order.slice(0, B).map(k => unl[k]); | |
| const short = order.slice(0, 4 * B); | |
| const anchors = Array.from(L).sort((a, b) => a - b); | |
| const dist = (p, q) => { let s = 0; for (let k = 0; k < 64; k++) { const t = p[k] - q[k]; s += t * t; } return Math.sqrt(s); }; | |
| const dmin = short.map(k => { let best = Infinity; for (const a of anchors) best = Math.min(best, dist(X[unl[k]], X[a])); return best; }); | |
| const used = short.map(() => false), picks = []; | |
| for (let r = 0; r < Math.min(B, short.length); r++) { | |
| let bk = -1, bs = -Infinity; | |
| for (let j = 0; j < short.length; j++) { | |
| if (used[j]) continue; | |
| const s = (1 - m[short[j]]) * dmin[j]; | |
| if (s > bs) { bs = s; bk = j; } | |
| } | |
| used[bk] = true; picks.push(unl[short[bk]]); | |
| for (let j = 0; j < short.length; j++) dmin[j] = Math.min(dmin[j], dist(X[unl[short[j]]], X[unl[short[bk]]])); | |
| } | |
| return picks; | |
| } | |
| function fit(ctx, labeled, labels) { | |
| return train(labeled.map(i => ctx.pool[i]), labels, ctx.hyper); | |
| } | |
| // Parity entry point: same inputs as the Python-generated cases. | |
| function runCase(ctx, input) { | |
| const W = fit(ctx, input.labeled, input.labels); | |
| const picks = select(ctx, input.strategy, W, input.labeled, input.B, input.seed); | |
| return { accuracy: accuracy(ctx, W), picks, proba_test0: Array.from(proba(W, ctx.test[0])) }; | |
| } | |
| return { ASSETS, init, train, fit, proba, margin, accuracy, select, runCase }; | |
| }); | |