neuroalpha 0.0.0-stage → 0.2.0

package/server/model/metrics.js

@@ -0,0 +1,134 @@
+import { round } from '../util.js';
+
+const MSK = 3 * 3600000;
+
+export function computeMetrics(trades, curve, capital) {
+  const n = trades.length;
+  const wins = trades.filter((t) => t.pnl > 0);
+  const losses = trades.filter((t) => t.pnl <= 0);
+  const grossProfit = wins.reduce((s, t) => s + t.pnl, 0);
+  const grossLoss = -losses.reduce((s, t) => s + t.pnl, 0);
+  const net = trades.reduce((s, t) => s + t.pnl, 0);
+
+  let peak = -Infinity, maxDD = 0;
+  for (const p of curve) {
+    peak = Math.max(peak, p.equity);
+    if (peak > 0) maxDD = Math.max(maxDD, (peak - p.equity) / peak);
+  }
+
+  // Шарп по дневным приращениям капитала, годовой
+  const daily = new Map();
+  for (const p of curve) daily.set(Math.floor((p.ts + MSK) / 86400000), p.equity);
+  const eq = [...daily.values()];
+  const rets = [];
+  for (let i = 1; i < eq.length; i++) if (eq[i - 1] > 0) rets.push(eq[i] / eq[i - 1] - 1);
+  let sharpe = null;
+  if (rets.length > 5) {
+    const m = rets.reduce((a, b) => a + b, 0) / rets.length;
+    const sd = Math.sqrt(rets.reduce((a, b) => a + (b - m) ** 2, 0) / (rets.length - 1));
+    sharpe = sd > 0 ? (m / sd) * Math.sqrt(252) : null;
+  }
+
+  const start = curve[0]?.equity ?? capital;
+  const end = curve.at(-1)?.equity ?? capital;
+  return {
+    trades: n,
+    winRate: n ? round((wins.length / n) * 100, 1) : null,
+    profitFactor: grossLoss > 0 ? round(grossProfit / grossLoss, 2) : (grossProfit > 0 ? null : null),
+    maxDrawdownPct: round(maxDD * 100, 2),
+    sharpe: sharpe === null ? null : round(sharpe, 2),
+    netPnl: round(net, 2),
+    returnPct: round((end / start - 1) * 100, 2),
+    avgTradePct: n ? round(trades.reduce((s, t) => s + t.pnlPct, 0) / n, 3) : null,
+    avgWin: wins.length ? round(grossProfit / wins.length, 2) : null,
+    avgLoss: losses.length ? round(-grossLoss / losses.length, 2) : null,
+    avgBarsHeld: n ? round(trades.reduce((s, t) => s + (t.barsHeld || 0), 0) / n, 1) : null,
+    commission: round(trades.reduce((s, t) => s + (t.commission || 0), 0), 2),
+    days: eq.length,
+  };
+}
+
+// Метрики полного периода, а также отдельно in-sample / out-of-sample
+export function computeReport(trades, curve, capital, oosPct) {
+  const full = computeMetrics(trades, curve, capital);
+  if (!curve.length || !oosPct) return { full };
+  const splitTs = curve[Math.floor(curve.length * (1 - oosPct / 100))]?.ts ?? curve.at(-1).ts;
+  const isCurve = curve.filter((p) => p.ts < splitTs);
+  const oosCurve = curve.filter((p) => p.ts >= splitTs);
+  return {
+    full,
+    inSample: computeMetrics(trades.filter((t) => t.entryTs < splitTs), isCurve, capital),
+    outOfSample: computeMetrics(trades.filter((t) => t.entryTs >= splitTs), oosCurve, capital),
+    splitTs,
+  };
+}
+
+export function downsample(curve, max = 1500) {
+  if (curve.length <= max) return curve;
+  const step = curve.length / max;
+  const out = [];
+  for (let i = 0; i < max; i++) out.push(curve[Math.floor(i * step)]);
+  out.push(curve.at(-1));
+  return out;
+}
+
+const ymOf = (ts) => {
+  const d = new Date(ts + MSK);
+  return `${d.getUTCFullYear()}-${String(d.getUTCMonth() + 1).padStart(2, '0')}`;
+};
+const pct = (a, b) => (b > 0 ? round((a / b - 1) * 100, 2) : null);
+
+// Доходность по календарным месяцам и годам (по МСК): конец периода к концу предыдущего, первый — к первой точке кривой
+export function periodReturns(curve, capital) {
+  if (!curve?.length) return { months: [], years: [], last12: null };
+  const monthEnd = new Map();
+  for (const p of curve) monthEnd.set(ymOf(p.ts), p.equity);
+  const months = [];
+  let prev = curve[0].equity ?? capital;
+  for (const [ym, eq] of monthEnd) {
+    months.push({ ym, ret: pct(eq, prev), eq });
+    prev = eq;
+  }
+  const yearEnd = new Map(), yearMonths = new Map();
+  for (const m of months) {
+    const y = +m.ym.slice(0, 4);
+    yearEnd.set(y, m.eq);
+    yearMonths.set(y, (yearMonths.get(y) || 0) + 1);
+  }
+  const years = [];
+  prev = curve[0].equity ?? capital;
+  for (const [y, eq] of yearEnd) {
+    years.push({ y, ret: pct(eq, prev), months: yearMonths.get(y), partial: yearMonths.get(y) < 12 });
+    prev = eq;
+  }
+  const last = curve.at(-1);
+  const base = [...curve].reverse().find((p) => p.ts <= last.ts - 365 * 86400000) || curve[0];
+  return { months: months.map(({ ym, ret }) => ({ ym, ret })), years, last12: pct(last.equity, base.equity) };
+}
+
+// Сводка для интерфейса: торгующая модель (с комиссиями и без), рынок и остальные модели
+export function buildPeriods({ model, gross, market, models }, capital, splitTs) {
+  const pm = periodReturns(model, capital), pg = periodReturns(gross, capital), pk = periodReturns(market, capital);
+  const po = Object.fromEntries(Object.entries(models).map(([n, c]) => [n, periodReturns(c, capital)]));
+  const find = (arr, key, v) => arr.find((x) => x[key] === v)?.ret ?? null;
+  // месяц относится к контрольному периоду, если его середина — после границы (то есть больше половины дней)
+  const oosMonth = (ym) => {
+    if (!splitTs) return false;
+    const [y, m] = ym.split('-').map(Number);
+    const a = Date.UTC(y, m - 1, 1) - MSK, b = Date.UTC(y, m, 1) - MSK;
+    return splitTs <= (a + b) / 2;
+  };
+  return {
+    months: pm.months.map((m) => ({
+      ym: m.ym, model: m.ret, gross: find(pg.months, 'ym', m.ym), market: find(pk.months, 'ym', m.ym),
+      models: Object.fromEntries(Object.entries(po).map(([n, r]) => [n, find(r.months, 'ym', m.ym)])),
+      oos: oosMonth(m.ym),
+    })),
+    years: pm.years.map((y) => ({
+      y: y.y, model: y.ret, gross: find(pg.years, 'y', y.y), market: find(pk.years, 'y', y.y),
+      models: Object.fromEntries(Object.entries(po).map(([n, r]) => [n, find(r.years, 'y', y.y)])),
+      partial: y.partial, months: y.months,
+    })),
+    last12: { model: pm.last12, market: pk.last12 },
+  };
+}

package/server/model/models.js

@@ -0,0 +1,459 @@
+import { eigenSym, ridgeSolve, matrix, spearman, kmeans } from './linalg.js';
+import { BAR_INTERVAL } from './dataset.js';
+
+// Масштабы «контекста» в свечах (свеча = 10 минут): последний час, 2 часа до этого, предыдущие 5 часов
+const H1 = 60 / BAR_INTERVAL;
+export const SCALES = [
+  { from: 0, len: H1, label: 'последний час' },
+  { from: H1, len: 2 * H1, label: '2 часа до этого' },
+  { from: 3 * H1, len: 5 * H1, label: 'предыдущие 5 часов' },
+];
+// сколько свечей назад смотрят самые длинные признаки контекста (5 часов до этого, начиная с 3 часов)
+export const FEATURE_WARMUP = (3 + 5) * H1;
+export const KINDS = [{ id: 'price', label: 'движение цены' }, { id: 'flow', label: 'денежный поток (движение × необычность оборота)' }];
+export const BETAS = [{ v: 4, label: 'широкое' }, { v: 12, label: 'узкое' }];
+export const HEADS = [];
+for (const k of KINDS) for (const s of SCALES) for (const b of BETAS) HEADS.push({ kind: k.id, scale: SCALES.indexOf(s), beta: b.v, label: `${k.label}, ${s.label}, ${b.label} внимание` });
+
+// ---------- контекст одного шага обучения ----------
+// trainStart..testStart — окно обучения; testStart..testEnd — месяц прогноза.
+// Все массивы «по времени»: [u*N + i], u = t - lo.
+// textWeight (0..1) — вес «текстовой» близости по профилям бизнеса; profiles — Map(тикер → 20 чисел), загружается один раз на исследование.
+export function buildFold(ds, { trainStart, testStart, testEnd, H, embedDim, textWeight = 0, profiles = null }) {
+  const { tokens, mret, T } = ds;
+  const N = tokens.length;
+  const lo = Math.max(1, trainStart - FEATURE_WARMUP);
+  const hi = Math.min(T, testEnd + H + 2);
+  const W = hi - lo;
+
+  // чувствительность к рынку и обычный размах — только по окну обучения
+  const beta = new Float64Array(N), sigma = new Float64Array(N);
+  let mm = 0, mv = 0;
+  const n0 = testStart - trainStart;
+  for (let t = trainStart; t < testStart; t++) mm += mret[t];
+  mm /= n0;
+  for (let t = trainStart; t < testStart; t++) mv += (mret[t] - mm) ** 2;
+  for (let i = 0; i < N; i++) {
+    const r = tokens[i].ret;
+    let ri = 0, cov = 0;
+    for (let t = trainStart; t < testStart; t++) ri += r[t];
+    ri /= n0;
+    for (let t = trainStart; t < testStart; t++) cov += (r[t] - ri) * (mret[t] - mm);
+    beta[i] = mv > 0 ? cov / mv : 1;
+    let s2 = 0;
+    for (let t = trainStart; t < testStart; t++) { const e = r[t] - beta[i] * mret[t]; s2 += e * e; }
+    sigma[i] = Math.max(Math.sqrt(s2 / n0), 1e-4);
+  }
+
+  // остаточное движение (без общего рынка), нормированное на обычный размах
+  const z = new Float64Array(W * N), has = new Uint8Array(W * N), liq = new Uint8Array(W * N), vr = new Float64Array(W * N);
+  for (let u = 0; u < W; u++) {
+    const t = lo + u;
+    for (let i = 0; i < N; i++) {
+      const e = tokens[i].ret[t] - beta[i] * mret[t];
+      z[u * N + i] = Math.max(-8, Math.min(8, e / sigma[i]));
+      has[u * N + i] = tokens[i].has[t];
+      liq[u * N + i] = tokens[i].liq[t];
+      vr[u * N + i] = Math.min(4, tokens[i].valRatio[t]);
+    }
+  }
+  // признаки контекста: 2 вида × 3 масштаба (Float32 — признаки не требуют двойной точности, память вдвое меньше)
+  const X = KINDS.map(() => SCALES.map(() => new Float32Array(W * N)));
+  SCALES.forEach((sc, si) => {
+    const Xp = X[0][si], Xf = X[1][si];
+    const invP = 1 / Math.sqrt(sc.len), invF = invP / 1.5;
+    const sp = new Float64Array(N), sf = new Float64Array(N);
+    for (let u = 0; u < W; u++) {
+      const a = u - sc.from, b = u - sc.from - sc.len;
+      if (a >= 0) {
+        const offA = a * N;
+        for (let i = 0; i < N; i++) { const zk = z[offA + i]; sp[i] += zk; sf[i] += zk * vr[offA + i]; }
+      }
+      if (b >= 0) {
+        const offB = b * N;
+        for (let i = 0; i < N; i++) { const zk = z[offB + i]; sp[i] -= zk; sf[i] -= zk * vr[offB + i]; }
+      }
+      if (u >= FEATURE_WARMUP) {
+        const offU = u * N;
+        for (let i = 0; i < N; i++) { Xp[offU + i] = sp[i] * invP; Xf[offU + i] = sf[i] * invF; }
+      }
+    }
+  });
+  // цель: остаточное (без рынка) движение, которое реально можно получить: решение на закрытии свечи t,
+  // вход по цене открытия t+1, выход по цене открытия t+1+H
+  const { mopen } = ds;
+  const yz = new Float64Array(W * N), yraw = new Float64Array(W * N), yok = new Uint8Array(W);
+  for (let u = 0; u + 1 + H < W; u++) {
+    const t = lo + u;
+    const ma = mopen[t + 1], mb = mopen[t + 1 + H];
+    if (!(ma > 0 && mb > 0)) continue;
+    yok[u] = 1;
+    const m = Math.log(mb / ma);
+    for (let i = 0; i < N; i++) {
+      const a = tokens[i].open[t + 1], b = tokens[i].open[t + 1 + H];
+      const r = a > 0 && b > 0 ? Math.log(b / a) - beta[i] * m : 0;
+      yraw[u * N + i] = r;
+      yz[u * N + i] = Math.max(-8, Math.min(8, r / (sigma[i] * Math.sqrt(H))));
+    }
+  }
+
+  // ---------- карта рынка: эмбеддинги из матрицы совместных движений ----------
+  const C = matrix(N, N);
+  const u0 = trainStart - lo, u1 = testStart - lo;
+  for (let u = u0; u < u1; u++) {
+    const off = u * N;
+    for (let i = 0; i < N; i++) {
+      const zi = z[off + i];
+      if (zi === 0) continue;
+      const Ci = C[i];
+      for (let j = i; j < N; j++) Ci[j] += zi * z[off + j];
+    }
+  }
+  for (let i = 0; i < N; i++) for (let j = i; j < N; j++) { C[i][j] /= (u1 - u0); C[j][i] = C[i][j]; }
+  const diag = Array.from({ length: N }, (_, i) => Math.sqrt(Math.max(C[i][i], 1e-9)));
+  for (let i = 0; i < N; i++) for (let j = 0; j < N; j++) C[i][j] /= diag[i] * diag[j];
+  const eig = eigenSym(C, { maxSweeps: 30 });
+  const d = Math.min(embedDim, N - 1);
+  const emb = Array.from({ length: N }, (_, i) => Float64Array.from({ length: d }, (_, c) => eig.vectors[c][i] * Math.sqrt(Math.max(eig.values[c], 0))));
+  const embN = emb.map((e) => { const n = Math.hypot(...e) || 1; return e.map((v) => v / n); });
+  const cos = matrix(N, N);
+  for (let i = 0; i < N; i++) for (let j = 0; j < N; j++) { let s = 0; for (let c = 0; c < d; c++) s += embN[i][c] * embN[j][c]; cos[i][j] = s; }
+  let eigVals = eig.values.slice(0, d);
+
+  // ---------- смешивание с «текстовой» близостью (устойчивые признаки бизнеса из профилей ИИ) ----------
+  // итог: cos = (1−w)·близость по поведению + w·близость по центрированным профилям;
+  // у пары акций без профиля — только поведенческая близость. Эмбеддинги карты пересчитываются из смешанной матрицы.
+  const tw = Math.max(0, Math.min(1, Number(textWeight) || 0));
+  if (tw > 0 && profiles?.size) {
+    const pv = tokens.map((t) => { const v = profiles.get(t.symbol); return Array.isArray(v) && v.every((x) => Number.isFinite(x)) ? v : null; });
+    const L = pv.find(Boolean)?.length || 0;
+    const have = pv.filter(Boolean).length;
+    if (L >= 2 && have >= 2) {
+      // центрируем профили: вычитаем среднее по признаку, иначе все компании «похожи» из-за общих единиц шкалы
+      const mean = new Float64Array(L);
+      for (const v of pv) if (v) for (let f = 0; f < L; f++) mean[f] += v[f] ?? 0;
+      for (let f = 0; f < L; f++) mean[f] /= have;
+      const cent = pv.map((v) => (v ? Float64Array.from({ length: L }, (_, f) => (v[f] ?? 0) - mean[f]) : null));
+      const nrm = cent.map((c) => (c ? Math.sqrt(c.reduce((s, x) => s + x * x, 0)) : 0));
+      for (let i = 0; i < N; i++) for (let j = 0; j < N; j++) {
+        let t = null;
+        if (cent[i] && cent[j] && nrm[i] > 0 && nrm[j] > 0) {
+          let s = 0; for (let f = 0; f < L; f++) s += cent[i][f] * cent[j][f];
+          t = s / (nrm[i] * nrm[j]);
+        }
+        const beh = cos[i][j];
+        cos[i][j] = (1 - tw) * beh + tw * (t === null ? beh : t);
+      }
+      // эмбеддинги и «головы внимания» дальше используют смешанную матрицу
+      const em = eigenSym(cos, { maxSweeps: 30 });
+      for (let i = 0; i < N; i++) {
+        const e = Float64Array.from({ length: d }, (_, c) => em.vectors[c][i] * Math.sqrt(Math.max(em.values[c], 0)));
+        const n = Math.hypot(...e) || 1;
+        emb[i] = e;
+        embN[i] = e.map((v) => v / n);
+      }
+      eigVals = em.values.slice(0, d);
+    }
+  }
+
+  // ---------- макро-головы: чувствительность остатков акций к макро-инструментам (только окно обучения) ----------
+  let macro = null;
+  if (ds.macro?.length) {
+    const list = [];
+    for (const m of ds.macro) {
+      // размах макро — только по торгованным барам окна обучения (у валют/фьючерсов могут быть пустоты)
+      let cnt = 0, mm = 0;
+      for (let t = trainStart; t < testStart; t++) if (m.has[t]) { mm += m.ret[t]; cnt++; }
+      if (cnt < n0 * 0.2) continue; // макро почти не торговался в окне — пропускаем
+      mm /= cnt;
+      let mv = 0;
+      for (let t = trainStart; t < testStart; t++) if (m.has[t]) mv += (m.ret[t] - mm) ** 2;
+      const msig = Math.max(Math.sqrt(mv / Math.max(cnt, 1)), 1e-6);
+      // бета остаточного движения акции к доходности макро
+      const b = new Float64Array(N);
+      for (let i = 0; i < N; i++) {
+        const r = tokens[i].ret;
+        let cov = 0;
+        for (let t = trainStart; t < testStart; t++) if (m.has[t]) cov += (r[t] - beta[i] * mret[t]) * (m.ret[t] - mm);
+        b[i] = mv > 0 ? cov / mv : 0;
+      }
+      // z-движения макро и их масштабные суммы (как признаки контекста у акций)
+      const z = new Float32Array(W);
+      for (let u = 0; u < W; u++) { const v = m.ret[lo + u] / msig; z[u] = Math.max(-8, Math.min(8, v)); }
+      const zs = new Float32Array(SCALES.length * W);
+      SCALES.forEach((sc, si) => {
+        const out = zs.subarray(si * W, (si + 1) * W);
+        let sum = 0;
+        for (let u = 0; u < W; u++) {
+          const a = u - sc.from, bb = u - sc.from - sc.len;
+          if (a >= 0) sum += z[a];
+          if (bb >= 0) sum -= z[bb];
+          out[u] = a >= 0 ? sum / Math.sqrt(sc.len) : 0;
+        }
+      });
+      list.push({ id: m.id, label: m.label, b, zs });
+    }
+    if (list.length) macro = { list };
+  }
+
+  return { N, lo, hi, W, trainStart, testStart, testEnd, H, beta, sigma, z, has, liq, X, yz, yraw, yok, emb, embN, cos, eigenvalues: eigVals, macro };
+}
+
+// Ликвидная акция: сделки хотя бы в 15 из последних 20 свечей
+export const LIQ_MIN = 15;
+
+// В обучение — только моменты, цель которых целиком лежит в окне обучения (без заглядывания в месяц прогноза)
+export const trainUs = (f) => {
+  const us = [];
+  for (let t = f.trainStart + FEATURE_WARMUP; t < f.testStart - f.H - 1; t++) { const u = t - f.lo; if (f.yok[u]) us.push(u); }
+  return us;
+};
+
+// Сводная (общая для всех акций) гребневая регрессия: y ~ features
+function pooledFit(f, featFn, p, lambdaRel = 1e-3) {
+  const A = matrix(p, p), b = matrix(p, 1);
+  const x = new Float64Array(p);
+  for (const u of trainUs(f)) {
+    for (let i = 0; i < f.N; i++) {
+      if (!f.has[u * f.N + i] || f.liq[u * f.N + i] < LIQ_MIN) continue;
+      featFn(u, i, x);
+      const y = f.yz[u * f.N + i];
+      for (let a = 0; a < p; a++) {
+        const xa = x[a];
+        if (xa === 0) continue;
+        b[a][0] += xa * y;
+        const Aa = A[a];
+        for (let c = a; c < p; c++) Aa[c] += xa * x[c];
+      }
+    }
+  }
+  let tr = 0;
+  for (let a = 0; a < p; a++) { for (let c = 0; c < a; c++) A[a][c] = A[c][a]; tr += A[a][a]; }
+  return ridgeSolve(A, b, (tr / p) * lambdaRel).map((r) => r[0]);
+}
+
+// ---------- ступень 0: своя инерция ----------
+export function fitInertia(f) {
+  const coef = pooledFit(f, (u, i, x) => { for (let s = 0; s < 3; s++) x[s] = f.X[0][s][u * f.N + i]; }, 3);
+  return { name: 'inertia', coef };
+}
+function predictInertia(m, f, u) {
+  const out = new Float64Array(f.N);
+  for (let i = 0; i < f.N; i++) { let s = 0; for (let k = 0; k < 3; k++) s += m.coef[k] * f.X[0][k][u * f.N + i]; out[i] = s; }
+  return out;
+}
+
+// ---------- ступень 1: кто за кем ходит (линейное «внимание» без карты) ----------
+export function fitLeadLag(f) {
+  const N = f.N, p = 2 * N;
+  const us = trainUs(f);
+  const split = Math.floor(us.length * 0.8);
+  const accum = (list) => {
+    const A = matrix(p, p), B = matrix(p, N);
+    const x = new Float64Array(p);
+    for (const u of list) {
+      for (let i = 0; i < N; i++) { x[i] = f.X[0][0][u * N + i]; x[N + i] = f.X[0][1][u * N + i]; }
+      for (let a = 0; a < p; a++) {
+        const xa = x[a];
+        if (xa === 0) continue;
+        const Aa = A[a], Ba = B[a];
+        for (let c = a; c < p; c++) Aa[c] += xa * x[c];
+        for (let j = 0; j < N; j++) Ba[j] += xa * f.yz[u * N + j];
+      }
+    }
+    for (let a = 0; a < p; a++) for (let c = 0; c < a; c++) A[a][c] = A[c][a];
+    return { A, B };
+  };
+  const P1 = accum(us.slice(0, split)), P2 = accum(us.slice(split));
+  const trace = (A) => A.reduce((s, r, i) => s + r[i], 0) / p;
+  // выбор силы регуляризации на последних 20% окна обучения
+  let best = null;
+  for (const alpha of [3, 30, 300]) {
+    const Wt = ridgeSolve(P1.A, P1.B, trace(P1.A) * alpha);
+    let ic = 0, n = 0;
+    for (const u of us.slice(split)) {
+      const pred = predictLin(Wt, f, u);
+      ic += spearman(pred, f.yz.subarray(u * N, u * N + N)); n++;
+    }
+    ic /= n || 1;
+    if (!best || ic > best.ic) best = { alpha, ic };
+  }
+  const A = P1.A.map((r, a) => r.map((v, c) => v + P2.A[a][c]));
+  const B = P1.B.map((r, a) => r.map((v, c) => v + P2.B[a][c]));
+  return { name: 'leadlag', W: ridgeSolve(A, B, trace(A) * best.alpha), alpha: best.alpha };
+}
+function predictLin(Wt, f, u) {
+  const N = f.N, out = new Float64Array(N);
+  for (let a = 0; a < 2 * N; a++) {
+    const xa = a < N ? f.X[0][0][u * N + a] : f.X[0][1][u * N + a - N];
+    if (xa === 0) continue;
+    const Wa = Wt[a];
+    for (let j = 0; j < N; j++) out[j] += xa * Wa[j];
+  }
+  return out;
+}
+
+// ---------- ступень 2: внимание через карту рынка ----------
+// Голова h: влияние соседей i на акцию j с весом softmax(beta·близость), сама акция исключена
+export function attentionMatrices(f) {
+  const N = f.N;
+  return BETAS.map((b) => {
+    const A = new Float64Array(N * N);
+    for (let j = 0; j < N; j++) {
+      let s = 0;
+      for (let i = 0; i < N; i++) { if (i === j) continue; const w = Math.exp(b.v * f.cos[j][i]); A[j * N + i] = w; s += w; }
+      for (let i = 0; i < N; i++) A[j * N + i] /= s;
+    }
+    return A;
+  });
+}
+
+export function headFeatures(f, As) {
+  const { N, W } = f;
+  const F = HEADS.map(() => new Float32Array(W * N));
+  for (let bIdx = 0; bIdx < BETAS.length; bIdx++) {
+    const betaVal = BETAS[bIdx].v;
+    const A = As[bIdx];
+    const hIdxs = [];
+    for (let hi = 0; hi < HEADS.length; hi++) if (HEADS[hi].beta === betaVal) hIdxs.push(hi);
+    const Xs = hIdxs.map((hi) => f.X[HEADS[hi].kind === 'price' ? 0 : 1][HEADS[hi].scale]);
+    const Fs = hIdxs.map((hi) => F[hi]);
+    const [X0, X1, X2, X3, X4, X5] = Xs;
+    const [F0, F1, F2, F3, F4, F5] = Fs;
+    for (let u = FEATURE_WARMUP; u < W; u++) {
+      const off = u * N;
+      for (let j = 0; j < N; j++) {
+        let s0 = 0, s1 = 0, s2 = 0, s3 = 0, s4 = 0, s5 = 0;
+        const row = j * N;
+        for (let i = 0; i < N; i++) {
+          const w = A[row + i];
+          const k = off + i;
+          s0 += w * X0[k]; s1 += w * X1[k]; s2 += w * X2[k];
+          s3 += w * X3[k]; s4 += w * X4[k]; s5 += w * X5[k];
+        }
+        const kj = off + j;
+        F0[kj] = s0; F1[kj] = s1; F2[kj] = s2;
+        F3[kj] = s3; F4[kj] = s4; F5[kj] = s5;
+      }
+    }
+  }
+  return F;
+}
+
+export function fitAttention(f) {
+  const As = attentionMatrices(f);
+  const F = headFeatures(f, As);
+  const ML = f.macro ? f.macro.list : [];
+  const Hn = HEADS.length;
+  const p = Hn + 3 + ML.length * SCALES.length;
+  const coef = pooledFit(f, (u, i, x) => {
+    const k = u * f.N + i;
+    for (let h = 0; h < Hn; h++) x[h] = F[h][k];
+    x[Hn] = f.X[0][0][k];
+    x[Hn + 1] = f.X[0][1][k];
+    x[Hn + 2] = f.X[0][2][k];
+    // макро-головы: бета акции к макро × z-движение макро на масштабе
+    for (let m = 0; m < ML.length; m++) {
+      const b = ML[m].b[i], zs = ML[m].zs, base = Hn + 3 + m * 3;
+      x[base] = b * zs[u];
+      x[base + 1] = b * zs[f.W + u];
+      x[base + 2] = b * zs[2 * f.W + u];
+    }
+  }, p, 1e-2);
+  const macroHeads = ML.flatMap((m, mi) => SCALES.map((sc, si) => ({ label: `${m.label}, ${sc.label}`, coef: coef[Hn + 3 + mi * 3 + si] })));
+  return { name: 'attention', coef, As, F, macroHeads };
+}
+function predictAttention(m, f, u) {
+  const ML = f.macro ? f.macro.list : [];
+  const out = new Float64Array(f.N);
+  for (let i = 0; i < f.N; i++) {
+    const k = u * f.N + i;
+    let s = 0;
+    for (let h = 0; h < HEADS.length; h++) s += m.coef[h] * m.F[h][k];
+    for (let q = 0; q < 3; q++) s += m.coef[HEADS.length + q] * f.X[0][q][k];
+    for (let mi = 0; mi < ML.length; mi++) {
+      let zz = 0;
+      const zs = ML[mi].zs;
+      for (let q = 0; q < 3; q++) zz += m.coef[HEADS.length + 3 + mi * 3 + q] * zs[q * f.W + u];
+      s += ML[mi].b[i] * zz;
+    }
+    out[i] = s;
+  }
+  return out;
+}
+
+export const MODELS = {
+  inertia: { label: 'Своя инерция', fit: fitInertia, predict: predictInertia },
+  leadlag: { label: 'Кто за кем ходит', fit: fitLeadLag, predict: (m, f, u) => predictLin(m.W, f, u) },
+  attention: { label: 'Внимание через карту', fit: fitAttention, predict: predictAttention },
+  // ступень 3: нейросеть с вниманием между акциями (tfjs грузится только при первом обучении);
+  // fit асинхронный, после использования модель нужно освободить: model.dispose()
+  transformer: {
+    label: 'Трансформер',
+    fit: async (f, opts) => (await import('./transformer.js')).fitTransformer(f, opts),
+    predict: (m, f, u) => m.predictOne(m, f, u),
+    predictMany: (m, f, us) => m.predictMany(m, f, us),
+    heavy: true,
+  },
+};
+
+// Какие модели обучать: три базовые всегда, трансформер — если включён для сравнения или торгует
+export const modelNames = (p) => Object.keys(MODELS).filter((n) => !MODELS[n].heavy || (n === 'transformer' && (p.modelUseTransformer || p.modelType === 'transformer')));
+
+// Объяснение прогноза «внимания»: вклад каждого соседа в прогноз акции j
+export function explainAttention(m, f, u, j, top = 3) {
+  const N = f.N;
+  const contrib = new Float64Array(N);
+  HEADS.forEach((h, hi) => {
+    const A = m.As[BETAS.findIndex((b) => b.v === h.beta)];
+    const X = f.X[h.kind === 'price' ? 0 : 1][h.scale];
+    for (let i = 0; i < N; i++) contrib[i] += m.coef[hi] * A[j * N + i] * X[u * N + i];
+  });
+  let self = 0;
+  for (let q = 0; q < 3; q++) self += m.coef[HEADS.length + q] * f.X[0][q][u * N + j];
+  const idx = [...contrib.keys()].filter((i) => i !== j).sort((a, b) => Math.abs(contrib[b]) - Math.abs(contrib[a])).slice(0, top);
+  return { neighbors: idx.map((i) => ({ i, contrib: contrib[i] })), self };
+}
+
+// 2D-координаты карты + кластеры
+export function mapSnapshot(f, k = 8) {
+  const pts = f.emb.map((e) => [e[0] || 0, e[1] || 0]);
+  const clusters = kmeans(f.embN.map((e) => Array.from(e)), Math.min(k, f.N), { seed: 11 });
+  return { pts, clusters };
+}
+
+// Совмещение карты с предыдущей (поворот/отражение), чтобы точки не «прыгали» между месяцами
+export function alignTo(prev, cur) {
+  if (!prev) return cur;
+  let best = null;
+  for (const flip of [1, -1]) {
+    let a = 0, b = 0;
+    for (let i = 0; i < cur.length; i++) {
+      const [x, y] = [cur[i][0], cur[i][1] * flip];
+      const [px, py] = prev[i];
+      a += x * px + y * py;
+      b += x * py - y * px;
+    }
+    const th = Math.atan2(b, a), c = Math.cos(th), s = Math.sin(th);
+    const out = cur.map(([x, y0]) => { const y = y0 * flip; return [c * x - s * y, s * x + c * y]; });
+    let err = 0;
+    for (let i = 0; i < out.length; i++) err += (out[i][0] - prev[i][0]) ** 2 + (out[i][1] - prev[i][1]) ** 2;
+    if (!best || err < best.err) best = { err, out };
+  }
+  return best.out;
+}
+
+// Перенумерация кластеров, чтобы цвета групп сохранялись между месяцами
+export function matchClusters(prev, cur, k) {
+  if (!prev) return cur;
+  const map = new Map(), used = new Set();
+  const pairs = [];
+  for (let a = 0; a < k; a++) for (let b = 0; b < k; b++) {
+    let n = 0;
+    for (let i = 0; i < cur.length; i++) if (cur[i] === a && prev[i] === b) n++;
+    pairs.push([n, a, b]);
+  }
+  pairs.sort((x, y) => y[0] - x[0]);
+  for (const [, a, b] of pairs) if (!map.has(a) && !used.has(b)) { map.set(a, b); used.add(b); }
+  return cur.map((c) => map.get(c) ?? c);
+}