Download core.js from thelamapi/Next-Echo: direct link, hf CLI and curl.
- Browser
- Download file 6.54 kB
-
https://huggingface.co/spaces/thelamapi/Next-Echo/resolve/main/core.js
- Command line
-
hf download hf://spaces/thelamapi/Next-Echo/core.js
-
curl -L -o core.js https://huggingface.co/spaces/thelamapi/Next-Echo/resolve/main/core.js
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 }; | |
| }); | |