neuroalpha 0.2.0 → 0.3.12

package/server/strategist/index.js

@@ -1,3 +1,4 @@
+// Copyright (c) 2026 Roman A. Perepelkin. Licensed under the MIT License.
 import { PARAMS } from '../params-meta.js';
 import { chatStream, activeModelInfo, isLlmEnabled } from '../llm/client.js';
 import { hub } from '../hub.js';
@@ -54,7 +55,8 @@ const emitMsg = (m, type = 'chat:message') => hub.emit({ type, message: m });
 // ---------- системная инструкция ----------
 function systemPrompt(mode) {
   const s = getSettings();
-  const params = PARAMS.map((p) => `- ${p.key} = ${JSON.stringify(s[p.key])} — ${p.label}${p.min !== undefined ? ` [${p.min}…${p.max}]` : ''}${p.ai === false ? ' (НЕ МЕНЯТЬ)' : ''}`).join('\n');
+const PARAMS_VISIBLE = PARAMS.filter((p) => !p.hidden && !p.fixed);
+  const params = PARAMS_VISIBLE.map((p) => `- ${p.key} = ${JSON.stringify(s[p.key])} — ${p.label}${p.min !== undefined ? ` [${p.min}…${p.max}]` : ''}${p.ai === false ? ' (НЕ МЕНЯТЬ)' : ''}`).join('\n');
   const journal = listJournal(30).reverse().map((j) => `- #${j.id} [${{ confirmed: 'подтвердилась', rejected: 'не подтвердилась', unclear: 'неясно' }[j.verdict] || j.verdict}] ${j.hypothesis}${j.change ? ` | изменение: ${j.change}` : ''} | итог: ${j.result}${j.run_ids?.length ? ` | проверки ${j.run_ids.map((x) => `№${x}`).join(', ')}` : ''}`).join('\n') || '(пусто — это первое исследование)';
   const runs = recentRuns(6).map((r) => `- №${r.id} (${r.тип}, ${r.кто_запустил}${r.заметка ? `, «${r.заметка}»` : ''}): отличия ${JSON.stringify(r.отличия_от_умолчаний)}; ${JSON.stringify(r.период_настройки || r.результат || r.ошибка || r.статус)}`).join('\n') || '(исследований ещё не было)';
   const ps = live.status();
@@ -76,16 +78,14 @@ function systemPrompt(mode) {
 Задача — как языковая модель предсказывает следующий токен, предсказать следующее состояние: какие акции сдвинутся в ближайшие часы и куда.
 Перетоки капитала видны как «волны» по карте: если двинулся сосед по карте, а акция ещё нет — она может догнать (или, наоборот, вернуться).
 
-Исследование идёт лесенкой (инструмент run_model_research, сравнивает все модели сразу):
+Исследование идёт лесенкой (инструмент run_model_research, сравнивает все три модели сразу):
 - «своя инерция» — простейшая планка: акция предсказывается по своему недавнему движению;
 - «кто за кем ходит» — линейная модель: каждая акция по недавним движениям всех остальных;
-- «внимание через карту» — влияние соседей по карте рынка (12 «голов внимания»: движение цены или денежный поток × 3 масштаба времени × широкое/узкое внимание);
-- «трансформер» (ступень 3, только при modelUseTransformer=true или modelType='transformer') — небольшая нейросеть: 2 слоя внимания между акциями, обучаемый эмбеддинг каждой акции, учится заново в каждом окне с ранней остановкой. Исследование с ним в разы дольше; данных мало, легко переобучается — верь ему, только если он обыгрывает «внимание через карту» и на контрольном периоде.
-  Его настройки: transformerEpochs (эпох, 2–40, по умолчанию 8) и transformerStride (шаг свечей, 1–24, по умолчанию 6) меняют результат; больше эпох / меньше шаг — дольше. transformerParallel (окна одновременно на ядрах) и transformerGpu (видеокарта, экспериментально) — только про скорость, их без просьбы пользователя не трогай.
+- «внимание через карту» — основная торгующая стратегия: влияние соседей по карте рынка (12 «голов внимания»: движение цены или денежный поток с почасовым суточным профилем объёма × 3 масштаба времени × широкое/узкое внимание);
 Метрики модели: «совпадение прогноза» (ранговая корреляция прогноза с фактом по акциям, 0.03+ уже ценно), доля недель с плюсом,
 доход портфеля из лучших прогнозов с комиссиями и БЕЗ комиссий (разница показывает, сколько съедают издержки), сравнение с рынком.
 Сделки исполняются по цене открытия следующей свечи (честно). Порог выгоды modelMinEdge: покупаем, только если ожидаемое движение больше стоимости сделки × порог.
-У стратегии включено самообучение правил торговли (modelAutoAdapt=true по умолчанию): она сама калибрует порог выхода (около 0,80 от порога входа, чтобы не пересиживать угасающие сделки в зоне 3–8 ч) по прошлым шагам с учётом комиссии и автоматически ставит на карантин акции, которые на прошлых сделках систематически приносили убыток («акции-убийцы»). Дополнительно есть ручные настройки: порог входа (modelMinEdge), порог выхода (modelExitRatio — действует при выключенном modelAutoAdapt), минимальное удержание (modelMinHoldHours, ч), число акций (modelTopK), способ распределения долей (modelAllocMode: equal / invvol), фильтр падающего рынка (modelMarketFilter: off / ma) и горизонт (modelHorizon).
+У стратегии включено самообучение правил торговли (modelAutoAdapt=true по умолчанию — Полный Автомат): мульти-горизонтное обучение (1.5–3.5 ч), сопровождение на полушаге H/2 (мягкий порог 0.35 на первых двух полушагах и 0.95 по зрелости), взвешивание слота по силе сигнала (Conviction Sizing), адаптация порогов покупок и продаж к среднесрочному тренду индекса Мосбиржи и временный карантин убыточных «акций-убийц» с затуханием. Дополнительно есть настройки: число акций (modelTopK), направление (modelDirection), способ распределения долей (modelAllocMode: equal / invvol), фильтр падающего рынка (modelMarketFilter: off / ma), а при выключенном modelAutoAdapt — ручные горизонт (modelHorizon), порог входа (modelMinEdge) и порог выхода (modelExitRatio).
 Направление modelDirection: long — только покупки (по умолчанию); longshort — ещё и продажи без покупки (шорт) акций, ожидаемо слабее рынка (ожидание ниже −порога); neutral — парами: равные суммы покупок и продаж, нет пары — не торгуем; общий рост или падение рынка почти не влияют, результат сравнивай с нулём, а не с рынком. С продажами на позицию приходится капитал/2К. За продажу брокер берёт плату за заём акций modelShortFeePct (% годовых за время удержания). В разборах есть вклад покупок и продаж и разбивка по стороне — смотри, какая сторона зарабатывает.
 Разница в итоге меньше 5 п.п. между двумя исследованиями обычно в пределах случайности — не называй её надёжной без контрольного периода.
 model_forecast — прогноз сейчас, market_neighbors — соседи акции на карте.

package/server/strategist/tools.js

@@ -1,3 +1,4 @@
+// Copyright (c) 2026 Roman A. Perepelkin. Licensed under the MIT License.
 import { PARAMS, PARAM_MAP } from '../params-meta.js';
 import { getSettings, updateSettings, validateChanges } from '../settings.js';
 import { getRun, listRuns, addJournal, listJournal, kvGet, kvSet } from '../db.js';
@@ -15,7 +16,7 @@ const AI_LOCKED = PARAMS.filter((p) => p.ai === false).map((p) => p.key);
 const changesSchema = {
   type: 'object',
   description: 'Изменения настроек: ключ — точное название настройки из списка в системной инструкции (например modelHorizon, modelMinEdge), значение — новое значение.',
-  properties: Object.fromEntries(PARAMS.filter((p) => p.ai !== false).map((p) => [p.key, {
+  properties: Object.fromEntries(PARAMS.filter((p) => p.ai !== false && !p.hidden && !p.fixed).map((p) => [p.key, {
     type: p.type === 'checkbox' ? 'boolean' : p.type === 'select' ? 'string' : 'number',
     description: `${p.label}${p.min !== undefined ? ` (${p.min}–${p.max})` : ''}`,
   }])),

package/server/util.js

@@ -1,3 +1,4 @@
+// Copyright (c) 2026 Roman A. Perepelkin. Licensed under the MIT License.
 export const DAY = 86400000;
 export const MSK = 3 * 3600000;
 export const round = (v, d = 2) => (Number.isFinite(v) ? Math.round(v * 10 ** d) / 10 ** d : v);

package/server/model/gpu-worker.html

@@ -1,11 +0,0 @@
-<!doctype html>
-<html lang="ru">
-<head>
-<meta charset="utf-8">
-<title>Обучение трансформера на видеокарте</title>
-<!-- служебная страница: открывается безголовым браузером, человеку здесь смотреть не на что -->
-<script src="/tf/tf.min.js"></script>
-<script type="module" src="/gpu/gpu-worker.js"></script>
-</head>
-<body>Обучение трансформера на видеокарте</body>
-</html>

package/server/model/gpu-worker.js

@@ -1,60 +0,0 @@
-// Браузерная часть обучения на видеокарте: подключается к серверу, сообщает, какая видеокарта,
-// и обучает окна тем же кодом, что и в Node (tf — глобальный, из tf.min.js; движок WebGL).
-import { fitPredictCore, pack, unpack } from './transformer-core.js';
-
-/* global tf */
-const token = new URLSearchParams(location.search).get('token');
-const ws = new WebSocket(`ws://${location.host}/gpu-ws?token=${token}`);
-ws.binaryType = 'arraybuffer';
-let cancelled = false;
-
-// Какая видеокарта реально рисует: WEBGL_debug_renderer_info (программную отрисовку сервер отбракует)
-function gpuInfo() {
-  const c = document.createElement('canvas');
-  const gl = c.getContext('webgl2') || c.getContext('webgl');
-  if (!gl) return { webgl: false };
-  const ext = gl.getExtension('WEBGL_debug_renderer_info');
-  return {
-    webgl: true,
-    renderer: String(ext ? gl.getParameter(ext.UNMASKED_RENDERER_WEBGL) : gl.getParameter(gl.RENDERER)),
-    vendor: String(ext ? gl.getParameter(ext.UNMASKED_VENDOR_WEBGL) : gl.getParameter(gl.VENDOR)),
-  };
-}
-
-ws.onopen = async () => {
-  const info = gpuInfo();
-  let backend = null, float32 = false, error = null;
-  if (info.webgl) {
-    try {
-      tf.enableProdMode();
-      if (await tf.setBackend('webgl')) backend = tf.getBackend();
-      await tf.ready();
-      float32 = !!tf.env().getBool('WEBGL_RENDER_FLOAT32_ENABLED');
-    } catch (e) { error = e.message; }
-  }
-  ws.send(JSON.stringify({ type: 'hello', ...info, backend, float32, error }));
-};
-
-ws.onmessage = async (ev) => {
-  if (typeof ev.data === 'string') {
-    if (JSON.parse(ev.data).type === 'cancel') cancelled = true;
-    return;
-  }
-  const m = unpack(ev.data);
-  const { id } = m;
-  try {
-    const r = await fitPredictCore(tf, m.input, m.us, {
-      cfg: m.cfg,
-      isCancelled: () => cancelled,
-      onProgress: (x) => ws.send(JSON.stringify({ type: 'progress', id, ...x })),
-    });
-    const N = m.input.N, us = Int32Array.from(r.preds.keys());
-    const flat = new Float64Array(us.length * N);
-    us.forEach((u, k) => flat.set(r.preds.get(u), k * N));
-    ws.send(pack({ id, us, flat, info: { ...r.info, tensors: tf.memory().numTensors, backend: tf.getBackend() } }));
-  } catch (e) {
-    ws.send(JSON.stringify({ type: 'error', id, error: e.message, cancelled }));
-  }
-};
-
-ws.onclose = () => window.close();

package/server/model/tf-node.js

@@ -1,26 +0,0 @@
-// Загрузка TensorFlow.js в Node (главный поток или рабочий поток): WASM, если не вышло — обычный процессорный движок.
-// Отдельный модуль без других зависимостей проекта: его грузят рабочие потоки, которым не нужна база и биржа.
-let tfReady = null;
-export function loadTf() {
-  if (!tfReady) tfReady = (async () => {
-    // tfjs в Node при загрузке советует поставить tfjs-node — нативную сборку мы сознательно не используем
-    const warn = console.warn;
-    console.warn = (...a) => { if (!String(a[0] ?? '').includes('tfjs-node')) warn(...a); };
-    let tf;
-    try {
-      tf = await import('@tensorflow/tfjs');
-      tf.enableProdMode();
-      let ok = false;
-      try {
-        await import('@tensorflow/tfjs-backend-wasm');
-        ok = await tf.setBackend('wasm');
-      } catch { ok = false; }
-      if (!ok) await tf.setBackend('cpu');
-      await tf.ready();
-    } finally {
-      console.warn = warn;
-    }
-    return tf;
-  })().catch((e) => { tfReady = null; throw e; });
-  return tfReady;
-}

package/server/model/transformer-core.js

@@ -1,330 +0,0 @@
-// Ядро трансформера: обучение и прогноз. Один и тот же код работает и в Node (главный поток, рабочие потоки),
-// и в браузере (обучение на видеокарте через WebGL), поэтому здесь нет импортов Node — tf передаётся параметром.
-//
-// Модель: в момент t каждая акция — «токен»: её признаки контекста (+ обучаемый эмбеддинг акции);
-// слои энкодера смешивают информацию между акциями; на выходе — прогноз нормированной цели yz для каждой акции.
-//
-// На вход — «облегчённое окно» (см. transformerInput в transformer.js): только нужные для обучения массивы
-// { N, W, H, X, liq, has, yz, macro: { list: [{ b, zs }] } | null, tr: моменты обучения, liqMin }.
-import { mulberry32, spearman } from './linalg.js';
-
-export const TF_CFG = {
-  d: 24, heads: 2, layers: 2, ff: 48, dropout: 0.1,
-  lr: 2e-3, weightDecay: 0.1, batch: 32, epochs: 8, patience: 2,
-  // соседние 10-минутные моменты почти одинаковы: в эпоху берём каждую 6-ю свечу,
-  // со сдвигом от эпохи к эпохе (за 6 эпох модель видит все моменты); проверка — каждая 3-я свеча
-  stride: 6, valStride: 3,
-  valFrac: 0.2, seed: 20261013,
-};
-
-// Короткая пауза, чтобы успели обработаться другие события (отмена, прогресс).
-// В Node — setImmediate, в браузере — MessageChannel (setTimeout в браузере медленнее)
-const tick = (() => {
-  if (typeof setImmediate === 'function') return () => new Promise((r) => setImmediate(r));
-  const ch = new MessageChannel();
-  const q = [];
-  ch.port1.onmessage = () => q.shift()?.();
-  return () => new Promise((r) => { q.push(r); ch.port2.postMessage(0); });
-})();
-
-// Признаки акции i в момент u: 6 признаков контекста, флаги ликвидности, макро (бета акции × движение макро)
-function featCount(f) {
-  return 6 + 2 + (f.macro ? f.macro.list.length * 3 : 0);
-}
-function fillFeat(f, u, out, off) {
-  const { N } = f;
-  const ML = f.macro ? f.macro.list : [];
-  const F = featCount(f);
-  for (let i = 0; i < N; i++) {
-    const k = u * N + i, o = off + i * F;
-    for (let s = 0; s < 3; s++) { out[o + s] = f.X[0][s][k]; out[o + 3 + s] = f.X[1][s][k]; }
-    out[o + 6] = f.liq[k] / 20;
-    out[o + 7] = f.has[k];
-    for (let m = 0; m < ML.length; m++) for (let s = 0; s < 3; s++) out[o + 8 + m * 3 + s] = ML[m].b[i] * ML[m].zs[s * f.W + u];
-  }
-}
-const liquidAt = (f, u, i) => f.has[u * f.N + i] && f.liq[u * f.N + i] >= f.liqMin;
-
-// Нормировка признаков — среднее и разброс только по моментам окна обучения (ликвидные акции)
-function featStats(f, us) {
-  const N = f.N, F = featCount(f);
-  const buf = new Float32Array(N * F);
-  const s1 = new Float64Array(F), s2 = new Float64Array(F);
-  let n = 0;
-  for (const u of us) {
-    fillFeat(f, u, buf, 0);
-    for (let i = 0; i < N; i++) {
-      if (!liquidAt(f, u, i)) continue;
-      n++;
-      for (let c = 0; c < F; c++) { const v = buf[i * F + c]; s1[c] += v; s2[c] += v * v; }
-    }
-  }
-  const mean = new Float32Array(F), inv = new Float32Array(F);
-  for (let c = 0; c < F; c++) {
-    mean[c] = n ? s1[c] / n : 0;
-    const sd = n ? Math.sqrt(Math.max(s2[c] / n - mean[c] ** 2, 0)) : 1;
-    inv[c] = sd > 1e-6 ? 1 / sd : 0;
-  }
-  // флаги ликвидности не центрируем — только масштаб
-  mean[6] = 0; mean[7] = 0; inv[6] = 1; inv[7] = 1;
-  return { mean, inv };
-}
-
-// Цель момента: yz, поперечно стандартизированная по ликвидным акциям (модель учит порядок «кто сильнее»)
-function targetAt(f, u, y, lm, off) {
-  const N = f.N;
-  let s = 0, s2 = 0, n = 0;
-  for (let i = 0; i < N; i++) if (liquidAt(f, u, i)) { const v = f.yz[u * N + i]; s += v; s2 += v * v; n++; }
-  if (n < 5) { for (let i = 0; i < N; i++) { y[off + i] = 0; lm[off + i] = 0; } return null; }
-  const m = s / n, sd = Math.sqrt(Math.max(s2 / n - m * m, 1e-9));
-  for (let i = 0; i < N; i++) {
-    const ok = liquidAt(f, u, i);
-    lm[off + i] = ok ? 1 : 0;
-    y[off + i] = ok ? Math.max(-5, Math.min(5, (f.yz[u * N + i] - m) / sd)) : 0;
-  }
-  return sd;
-}
-
-function makeBatch(f, us, norm) {
-  const N = f.N, F = featCount(f), B = us.length;
-  const x = new Float32Array(B * N * F), km = new Float32Array(B * N);
-  us.forEach((u, b) => {
-    fillFeat(f, u, x, b * N * F);
-    for (let i = 0; i < N; i++) {
-      const o = (b * N + i) * F;
-      for (let c = 0; c < F; c++) x[o + c] = Math.max(-6, Math.min(6, (x[o + c] - norm.mean[c]) * norm.inv[c]));
-      // ключи внимания — акции, торговавшиеся в последние 20 свечей
-      km[b * N + i] = f.liq[u * N + i] > 0 ? 0 : -1e9;
-    }
-  });
-  return { x, km, B };
-}
-
-function initWeights(tf, cfg, F, N) {
-  const { d, ff, layers } = cfg;
-  let seed = cfg.seed;
-  const glorot = (shape) => tf.variable(tf.initializers.glorotUniform({ seed: seed++ }).apply(shape));
-  const zeros = (n) => tf.variable(tf.zeros([n]));
-  const ones = (n) => tf.variable(tf.ones([n]));
-  const w = {
-    Win: glorot([F, d]), bin: zeros(d),
-    E: tf.variable(tf.initializers.randomNormal({ mean: 0, stddev: 0.02, seed: seed++ }).apply([N, d])),
-    L: [],
-    lnfg: ones(d), lnfb: zeros(d),
-    Wout: glorot([d, 1]), bout: zeros(1),
-    Wlin: tf.variable(tf.zeros([F, 1])),
-  };
-  for (let l = 0; l < layers; l++) {
-    w.L.push({
-      ln1g: ones(d), ln1b: zeros(d),
-      Wq: glorot([d, d]), Wk: glorot([d, d]), Wv: glorot([d, d]), Wo: glorot([d, d]), bo: zeros(d),
-      ln2g: ones(d), ln2b: zeros(d),
-      W1: glorot([d, ff]), b1: zeros(ff), W2: glorot([ff, d]), b2: zeros(d),
-    });
-  }
-  return w;
-}
-const allVars = (w) => [w.Win, w.bin, w.E, w.lnfg, w.lnfb, w.Wout, w.bout, w.Wlin, ...w.L.flatMap((l) => Object.values(l))];
-// затухание весов — только у матриц (не у сдвигов и норм)
-const decayVars = (w) => [w.Win, w.E, w.Wout, w.Wlin, ...w.L.flatMap((l) => [l.Wq, l.Wk, l.Wv, l.Wo, l.W1, l.W2])];
-
-// Прямой проход: x [B,N,F], km [B,N] (0 или −1e9) → прогноз [B,N]
-function forward(tf, w, cfg, x, km, B, N, train, seedRef) {
-  const { d, heads } = cfg;
-  const dh = d / heads;
-  const drop = (t) => (train && cfg.dropout > 0 ? tf.dropout(t, cfg.dropout, undefined, seedRef.v++) : t);
-  const ln = (t, g, b) => {
-    const { mean, variance } = tf.moments(t, -1, true);
-    return t.sub(mean).div(variance.add(1e-5).sqrt()).mul(g).add(b);
-  };
-  const lin = (t2, W, b) => (b ? tf.matMul(t2, W).add(b) : tf.matMul(t2, W));
-  const F = x.shape[2];
-  let h = lin(x.reshape([B * N, F]), w.Win, w.bin).reshape([B, N, d]).add(w.E);
-  const mask = km.reshape([B, 1, 1, N]);
-  const split = (t2) => t2.reshape([B, N, heads, dh]).transpose([0, 2, 1, 3]);
-  for (const L of w.L) {
-    const a = ln(h, L.ln1g, L.ln1b).reshape([B * N, d]);
-    const q = split(lin(a, L.Wq).mul(1 / Math.sqrt(dh))), k = split(lin(a, L.Wk)), v = split(lin(a, L.Wv));
-    // dropout — на выходах внимания и MLP (на самих весах внимания он втрое дороже по времени)
-    const att = tf.softmax(tf.matMul(q, k, false, true).add(mask));
-    const o = tf.matMul(att, v).transpose([0, 2, 1, 3]).reshape([B * N, d]);
-    h = h.add(drop(lin(o, L.Wo, L.bo)).reshape([B, N, d]));
-    const a2 = ln(h, L.ln2g, L.ln2b).reshape([B * N, d]);
-    const m = lin(tf.relu(lin(a2, L.W1, L.b1)), L.W2, L.b2);
-    h = h.add(drop(m).reshape([B, N, d]));
-  }
-  // + линейная «обходная» часть прямо от признаков: LayerNorm сглаживает величину движения,
-  // а для порога выгоды важны именно крупные прогнозы
-  return lin(ln(h, w.lnfg, w.lnfb).reshape([B * N, d]), w.Wout, w.bout).add(tf.matMul(x.reshape([B * N, F]), w.Wlin)).reshape([B, N]);
-}
-
-// Прогноз по моментам us: Map(u → Float64Array(N)) в единицах yz
-export function predictCore(tf, model, f, us) {
-  const N = f.N, F = featCount(f);
-  const out = new Map();
-  const step = 64;
-  for (let s = 0; s < us.length; s += step) {
-    const part = Array.from(us.slice(s, s + step));
-    const { x, km, B } = makeBatch(f, part, model.norm);
-    const t = tf.tidy(() => forward(tf, model.w, model.cfg, tf.tensor3d(x, [B, N, F]), tf.tensor2d(km, [B, N]), B, N, false, null));
-    const pr = t.dataSync();
-    t.dispose();
-    part.forEach((u, b) => {
-      const r = new Float64Array(N);
-      for (let i = 0; i < N; i++) r[i] = pr[b * N + i] * model.scale;
-      out.set(u, r);
-    });
-  }
-  return out;
-}
-
-const meanIc = (f, preds) => {
-  let s = 0, n = 0;
-  for (const [u, pr] of preds) {
-    const ok = [...pr.keys()].filter((i) => liquidAt(f, u, i));
-    if (ok.length < 5) continue;
-    s += spearman(ok.map((i) => pr[i]), ok.map((i) => f.yz[u * f.N + i])); n++;
-  }
-  return n ? s / n : 0;
-};
-
-// Обучение в окне. onProgress({ epoch, epochs }) — в начале каждой эпохи; isCancelled() → прерывание между батчами
-export async function fitCore(tf, f, { onProgress = () => {}, isCancelled = () => false, cfg: over = {} } = {}) {
-  const cfg = { ...TF_CFG, ...over };
-  const N = f.N, F = featCount(f);
-  // только моменты, цель которых целиком внутри окна обучения
-  const all = Array.from(f.tr);
-  const nVal = Math.max(1, Math.floor(all.length * cfg.valFrac));
-  // проверка для ранней остановки — последние 20% окна обучения
-  const valUs = all.slice(all.length - nVal).filter((u, k) => k % cfg.valStride === 0);
-  // зазор H+1 свечей: цели обучающих моментов не заходят в период проверки
-  const trUs0 = all.slice(0, all.length - nVal).filter((u) => u + f.H + 1 < valUs[0]);
-  const norm = featStats(f, all.filter((u, k) => k % cfg.valStride === 0));
-
-  // цели обучения заранее (поперечная стандартизация по моменту)
-  const Y = new Float32Array(trUs0.length * N), LM = new Float32Array(trUs0.length * N);
-  const trUs = [];
-  const rowOf = new Map();
-  trUs0.forEach((u, k) => {
-    if (targetAt(f, u, Y, LM, k * N) === null) return;
-    rowOf.set(u, k);
-    trUs.push(u);
-  });
-  if (trUs.length < cfg.batch * cfg.stride) throw new Error('Трансформер: слишком мало моментов для обучения');
-
-  // tidy освобождает начальные тензоры инициализаторов (переменные остаются)
-  const w = tf.tidy(() => initWeights(tf, cfg, F, N));
-  const vars = allVars(w), dvars = decayVars(w);
-  const nParams = vars.reduce((s, v) => s + v.size, 0);
-  const opt = tf.train.adam(cfg.lr);
-  const rnd = mulberry32(cfg.seed);
-  const seedRef = { v: cfg.seed * 7 };
-  // scale — множитель выхода; при обучении 1 (единицы поперечного разброса), после — калибровка
-  const model = { name: 'transformer', w, cfg, norm, scale: 1, nParams };
-  let best = null, bad = 0, epochsRun = 0;
-  const snapshot = () => vars.map((v) => tf.keep(v.clone()));
-  const freeSnap = (s) => s && s.forEach((t) => t.dispose());
-
-  try {
-    for (let ep = 0; ep < cfg.epochs; ep++) {
-      onProgress({ epoch: ep + 1, epochs: cfg.epochs });
-      await tick();
-      // фиксированный (по seed) порядок батчей
-      const order = trUs.filter((u, k) => k % cfg.stride === ep % cfg.stride);
-      for (let i = order.length - 1; i > 0; i--) { const j = Math.floor(rnd() * (i + 1)); [order[i], order[j]] = [order[j], order[i]]; }
-      for (let s = 0; s + cfg.batch <= order.length; s += cfg.batch) {
-        if (isCancelled()) throw new Error('Отменено');
-        const part = order.slice(s, s + cfg.batch);
-        const B = part.length;
-        const { x, km } = makeBatch(f, part, norm);
-        const y = new Float32Array(B * N), lm = new Float32Array(B * N);
-        part.forEach((u, b) => { const r = rowOf.get(u) * N; y.set(Y.subarray(r, r + N), b * N); lm.set(LM.subarray(r, r + N), b * N); });
-        tf.tidy(() => {
-          const xt = tf.tensor3d(x, [B, N, F]), kt = tf.tensor2d(km, [B, N]);
-          const yt = tf.tensor2d(y, [B, N]), mt = tf.tensor2d(lm, [B, N]);
-          // MSE только по ликвидным акциям
-          opt.minimize(() => forward(tf, w, cfg, xt, kt, B, N, true, seedRef).sub(yt).square().mul(mt).sum().div(mt.sum().maximum(1)), false, vars);
-          // AdamW: затухание весов отдельно от градиента
-          const k = 1 - cfg.lr * cfg.weightDecay;
-          for (const v of dvars) v.assign(v.mul(k));
-        });
-        if ((s / cfg.batch) % 4 === 3) await tick();
-      }
-      epochsRun = ep + 1;
-      // ранняя остановка по совпадению прогноза с целью на последних 20% окна обучения
-      const valIc = meanIc(f, predictCore(tf, model, f, valUs));
-      if (!best || valIc > best.valIc) {
-        freeSnap(best?.snap);
-        best = { valIc, epoch: ep + 1, snap: snapshot() };
-        bad = 0;
-      } else if (++bad >= cfg.patience) break;
-    }
-    // возвращаем веса лучшей эпохи
-    if (best) vars.forEach((v, k) => v.assign(best.snap[k]));
-    // калибровка масштаба на проверочной части окна обучения: прогноз в единицах yz (как у гребневых моделей),
-    // иначе осторожная нейросеть редко преодолевает «Порог выгоды». Отрицательный наклон → прогноз 0.
-    model.scale = 1;
-    let sxy = 0, sxx = 0;
-    for (const [u, pr] of predictCore(tf, model, f, valUs)) {
-      const ok = [...pr.keys()].filter((i) => liquidAt(f, u, i));
-      if (ok.length < 5) continue;
-      const mp = ok.reduce((s, i) => s + pr[i], 0) / ok.length, my = ok.reduce((s, i) => s + f.yz[u * N + i], 0) / ok.length;
-      for (const i of ok) { const a = pr[i] - mp; sxy += a * (f.yz[u * N + i] - my); sxx += a * a; }
-    }
-    model.scale = sxx > 0 ? Math.max(0, sxy / sxx) : 0;
-  } catch (e) {
-    freeSnap(best?.snap);
-    vars.forEach((v) => v.dispose());
-    opt.dispose();
-    throw e;
-  }
-  freeSnap(best?.snap);
-  opt.dispose();
-  model.info = { params: nParams, epochs: epochsRun, bestEpoch: best?.epoch ?? 0, valIc: best?.valIc ?? null, scale: model.scale, trainMoments: trUs.length, valMoments: valUs.length };
-  model.dispose = () => vars.forEach((v) => v.dispose());
-  return model;
-}
-
-// Обучение и сразу прогноз на моменты месяца прогноза: { preds: Map(u → Float64Array), info }
-export async function fitPredictCore(tf, f, us, opts) {
-  const model = await fitCore(tf, f, opts);
-  try {
-    const preds = predictCore(tf, model, f, us);
-    return { preds, info: model.info };
-  } finally {
-    model.dispose();
-  }
-}
-
-// ---------- упаковка в один двоичный блок (для передачи через WebSocket) ----------
-// [4 байта: длина заголовка][заголовок JSON][выравнивание до 8][массивы подряд, каждый с выравниванием до 8]
-const TA = { Float64Array, Float32Array, Int32Array, Uint32Array, Uint8Array, Int16Array, Uint16Array, Int8Array };
-export function pack(obj) {
-  const arrs = [];
-  let off = 0;
-  const header = JSON.stringify(obj, (k, v) => {
-    if (ArrayBuffer.isView(v) && !(v instanceof DataView)) {
-      const rec = { $ta: v.constructor.name, off, len: v.length };
-      arrs.push([v, off]);
-      off += Math.ceil(v.byteLength / 8) * 8;
-      return rec;
-    }
-    return v;
-  });
-  const hb = new TextEncoder().encode(header);
-  const base = Math.ceil((4 + hb.length) / 8) * 8;
-  const out = new Uint8Array(base + off);
-  new DataView(out.buffer).setUint32(0, hb.length, true);
-  out.set(hb, 4);
-  for (const [v, o] of arrs) out.set(new Uint8Array(v.buffer, v.byteOffset, v.byteLength), base + o);
-  return out;
-}
-export function unpack(data) {
-  // копия в собственный буфер: так массивы гарантированно выровнены
-  const u8 = new Uint8Array(data.byteLength);
-  u8.set(data instanceof ArrayBuffer ? new Uint8Array(data) : new Uint8Array(data.buffer, data.byteOffset, data.byteLength));
-  const hl = new DataView(u8.buffer).getUint32(0, true);
-  const base = Math.ceil((4 + hl) / 8) * 8;
-  const header = new TextDecoder().decode(u8.subarray(4, 4 + hl));
-  return JSON.parse(header, (k, v) => (v && typeof v === 'object' && v.$ta ? new TA[v.$ta](u8.buffer, base + v.off, v.len) : v));
-}