File size: 6,542 Bytes
2184fd3
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
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
117
118
119
120
121
122
123
124
125
126
127
128
129
/* 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 };
});