Next-Echo / core.js
Lamapi's picture
Publish Next-Echo space
2184fd3 verified
Raw History Blame Contribute Delete
6.54 kB
/* Next Echo compute core: port of echo_core.py (log-mel, learned window embeddings, log-mel baseline, detection). */
(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 SR = 16000, N_FFT = 512, HOP = 256, N_MELS = 64, WIN = 64, STEP = 16;
const WIN_SEC = (WIN - 1) * HOP / SR + N_FFT / SR;
const ASSETS = ["model.json"];
// iterative radix-2 FFT on (re, im) in place
function fft(re, im) {
const n = re.length;
for (let i = 1, j = 0; i < n; i++) {
let bit = n >> 1;
for (; j & bit; bit >>= 1) j ^= bit;
j ^= bit;
if (i < j) { [re[i], re[j]] = [re[j], re[i]]; [im[i], im[j]] = [im[j], im[i]]; }
}
for (let len = 2; len <= n; len <<= 1) {
const ang = -2 * Math.PI / len;
for (let i = 0; i < n; i += len) {
for (let k = 0; k < len / 2; k++) {
const wr = Math.cos(ang * k), wi = Math.sin(ang * k);
const ar = re[i + k + len / 2], ai = im[i + k + len / 2];
const tr = ar * wr - ai * wi, ti = ar * wi + ai * wr;
re[i + k + len / 2] = re[i + k] - tr; im[i + k + len / 2] = im[i + k] - ti;
re[i + k] += tr; im[i + k] += ti;
}
}
}
}
function logmel(ctx, x) {
if (x.length < N_FFT) { const y = new Float64Array(N_FFT); y.set(x); x = y; }
const n = 1 + Math.floor((x.length - N_FFT) / HOP), nb = N_FFT / 2 + 1, fb = ctx.fb.data;
const w = new Float64Array(N_FFT); for (let i = 0; i < N_FFT; i++) w[i] = 0.5 - 0.5 * Math.cos(2 * Math.PI * i / N_FFT);
const out = Array.from({ length: N_MELS }, () => new Float64Array(n));
const re = new Float64Array(N_FFT), im = new Float64Array(N_FFT), p = new Float64Array(nb);
for (let f = 0; f < n; f++) {
for (let i = 0; i < N_FFT; i++) { re[i] = x[f * HOP + i] * w[i]; im[i] = 0; }
fft(re, im);
for (let k = 0; k < nb; k++) p[k] = re[k] * re[k] + im[k] * im[k];
for (let m = 0; m < N_MELS; m++) { let s = 0; for (let k = 0; k < nb; k++) s += fb[m * nb + k] * p[k]; out[m][f] = Math.log(s + 1e-6); }
}
return out;
}
function padFrames(lm, n) {
if (lm[0].length >= n) return lm;
let mn = Infinity; for (const r of lm) for (const v of r) if (v < mn) mn = v;
return lm.map(r => { const o = new Float64Array(n).fill(mn); o.set(r); return o; });
}
function windowStarts(nFrames) { const s = []; for (let t = 0; t <= Math.max(nFrames - WIN, 0); t += STEP) s.push(t); return s; }
function norm(v) { let s = 0; for (const x of v) s += x * x; const n = Math.max(Math.sqrt(s), 1e-12); return Float64Array.from(v, x => x / n); }
function embedWindow(ctx, lm, s) {
const d = new Float64Array(N_MELS * WIN);
for (let m = 0; m < N_MELS; m++) for (let t = 0; t < WIN; t++) d[m * WIN + t] = (lm[m][s + t] - ctx.mu) / ctx.sd;
return norm(NLRT.forward(ctx.layers, NLRT.T([1, N_MELS, WIN], d)).data);
}
function statsWindow(ctx, lm, s) {
const v = new Float64Array(2 * N_MELS);
for (let m = 0; m < N_MELS; m++) {
let mean = 0; for (let t = 0; t < WIN; t++) mean += (lm[m][s + t] - ctx.mu) / ctx.sd; mean /= WIN;
let var_ = 0; for (let t = 0; t < WIN; t++) { const z = (lm[m][s + t] - ctx.mu) / ctx.sd - mean; var_ += z * z; }
v[m] = mean; v[N_MELS + m] = Math.sqrt(var_ / WIN);
}
let mm = 0; for (const x of v) mm += x; mm /= v.length;
return norm(v.map(x => x - mm));
}
function queryVectors(ctx, q) {
const lm = padFrames(logmel(ctx, q), WIN), starts = [];
for (let s = 0; s + WIN <= lm[0].length; s += 8) starts.push(s);
const e = starts.map(s => { let a = 0; for (let m = 0; m < N_MELS; m++) for (let t = 0; t < WIN; t++) a += lm[m][s + t]; return a / (N_MELS * WIN); });
const top = Math.max(...e), sel = starts.filter((_, i) => e[i] >= top - 1.5);
const qe = new Float64Array(64), qs = new Float64Array(2 * N_MELS);
for (const s of sel) { const a = embedWindow(ctx, lm, s), b = statsWindow(ctx, lm, s); a.forEach((v, i) => qe[i] += v / sel.length); b.forEach((v, i) => qs[i] += v / sel.length); }
return [norm(qe), norm(qs)];
}
function similarityCurves(ctx, q, rec, onProgress) {
const [qe, qs] = queryVectors(ctx, q);
const lm = padFrames(logmel(ctx, rec), WIN), starts = windowStarts(lm[0].length);
const learned = [], base = [];
starts.forEach((s, k) => {
const e = embedWindow(ctx, lm, s), b = statsWindow(ctx, lm, s);
let a1 = 0, a2 = 0; for (let i = 0; i < e.length; i++) a1 += e[i] * qe[i]; for (let i = 0; i < b.length; i++) a2 += b[i] * qs[i];
learned.push(a1); base.push(a2);
if (onProgress && k % 20 === 0) onProgress(k / starts.length);
});
return { times: starts.map(s => s * HOP / SR), learned, base };
}
function median(a) { const b = Array.from(a).sort((x, y) => x - y), n = b.length; return n % 2 ? b[(n - 1) / 2] : (b[n / 2 - 1] + b[n / 2]) / 2; }
function robustZ(c) { const med = median(c), mad = median(Array.from(c, v => Math.abs(v - med))) + 1e-6; return Array.from(c, v => (v - med) / (1.4826 * mad)); }
function finalScores(learned, base, cfg) {
const zl = robustZ(learned), zb = robustZ(base), a = cfg.alpha;
return [zl.map((v, i) => a * v + (1.0 - a) * zb[i]), cfg.baseline_norm === "z" ? zb : Array.from(base)];
}
function detect(times, sims, th) {
const out = []; let cur = null;
times.forEach((t, i) => {
if (sims[i] >= th) { if (cur === null) cur = [t, t + WIN_SEC, sims[i]]; else { cur[1] = t + WIN_SEC; cur[2] = Math.max(cur[2], sims[i]); } }
else if (cur !== null) { out.push(cur); cur = null; }
});
if (cur !== null) out.push(cur);
return out;
}
function init(assets) {
const m = NLRT.decode(assets["model.json"]);
return { layers: m.nets.embed, fb: m.tensors.mel_fb, mu: m.meta.mu, sd: m.meta.sd, thresholds: m.meta.thresholds, score: m.meta.score, meta: m.meta };
}
function runCase(ctx, input) {
const q = Float64Array.from(input.query, v => v / 32768), r = Float64Array.from(input.recording, v => v / 32768);
const c = similarityCurves(ctx, q, r), [nx, bl] = finalScores(c.learned, c.base, ctx.score);
return { learned: c.learned, base: c.base, det_learned: detect(c.times, nx, ctx.thresholds.learned), det_base: detect(c.times, bl, ctx.thresholds.baseline) };
}
return { ASSETS, init, SR, WIN_SEC, logmel, similarityCurves, finalScores, detect, runCase };
});