File size: 4,789 Bytes
c3dba1e | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 | /* 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 };
});
|