neuroalpha 0.0.0-stage → 0.2.0

package/server/model/tf-node.js

@@ -0,0 +1,26 @@
+// Загрузка 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

@@ -0,0 +1,330 @@
+// Ядро трансформера: обучение и прогноз. Один и тот же код работает и в 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));
+}

package/server/model/transformer-gpu.js

@@ -0,0 +1,221 @@
+// Обучение трансформера на видеокарте без нативных сборок: TensorFlow.js (WebGL) в безголовом браузере
+// на базе Chromium (Chrome, Edge, Chromium, Brave). Браузер запускается со своим временным профилем,
+// подключается к служебному мини-серверу (только 127.0.0.1) по WebSocket, получает данные окна двоично
+// и обучает тем же кодом, что и в Node (transformer-core.js).
+// Если браузера нет, WebGL недоступен или отрисовка программная — ошибка, вызывающий откатывается на процессор.
+import { spawn, spawnSync } from 'node:child_process';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import http from 'node:http';
+import crypto from 'node:crypto';
+import { fileURLToPath } from 'node:url';
+import express from 'express';
+import { WebSocketServer } from 'ws';
+import { pack, unpack } from './transformer-core.js';
+
+const HERE = path.dirname(fileURLToPath(import.meta.url));
+const ROOT = path.resolve(HERE, '../..');
+// программная отрисовка вместо видеокарты
+const SOFTWARE = /swiftshader|llvmpipe|softpipe|software|basic render|mesa offscreen|lavapipe/i;
+
+const exists = (p) => { try { return fs.statSync(p).isFile(); } catch { return false; } };
+
+// Поиск браузера: BROWSER_PATH → стандартные места установки для Windows / macOS / Linux
+export function findBrowser() {
+  if (process.env.BROWSER_PATH) return exists(process.env.BROWSER_PATH) ? process.env.BROWSER_PATH : null;
+  const list = [];
+  if (process.platform === 'win32') {
+    const bases = [process.env.PROGRAMFILES, process.env['PROGRAMFILES(X86)'], process.env.LOCALAPPDATA].filter(Boolean);
+    const rel = ['Google/Chrome/Application/chrome.exe', 'Microsoft/Edge/Application/msedge.exe', 'Chromium/Application/chrome.exe', 'BraveSoftware/Brave-Browser/Application/brave.exe'];
+    for (const r of rel) for (const b of bases) list.push(path.join(b, r));
+  } else if (process.platform === 'darwin') {
+    const apps = [['Google Chrome', 'Google Chrome'], ['Microsoft Edge', 'Microsoft Edge'], ['Chromium', 'Chromium'], ['Brave Browser', 'Brave Browser']];
+    for (const dir of ['/Applications', path.join(os.homedir(), 'Applications')]) for (const [app, bin] of apps) list.push(`${dir}/${app}.app/Contents/MacOS/${bin}`);
+  } else {
+    const names = ['google-chrome', 'google-chrome-stable', 'chromium', 'chromium-browser', 'microsoft-edge', 'microsoft-edge-stable', 'brave-browser'];
+    const dirs = (process.env.PATH || '').split(path.delimiter).filter(Boolean);
+    for (const n of names) for (const d of [...dirs, '/usr/bin', '/usr/local/bin', '/snap/bin']) list.push(path.join(d, n));
+  }
+  return list.find(exists) || null;
+}
+
+// Короткое название видеокарты из строки WebGL («ANGLE (NVIDIA, NVIDIA GeForce RTX 3060 (0x…) Direct3D11 …)»)
+function gpuName(renderer) {
+  const m = /^ANGLE \(([^,]*),\s*(.+?)(?:\s*\(0x[0-9a-f]+\))?(?:\s+Direct3D.*|\s+OpenGL.*|\s+Metal.*|,.*)?\)?$/i.exec(renderer || '');
+  return (m ? m[2] : renderer || 'неизвестно').trim();
+}
+
+// Завершение браузера со всеми его процессами — строго по своему PID (не по имени: у пользователя открыт свой браузер)
+function killTree(pid) {
+  if (!pid) return;
+  try {
+    if (process.platform === 'win32') spawnSync('taskkill', ['/PID', String(pid), '/T', '/F'], { stdio: 'ignore', windowsHide: true });
+    else process.kill(-pid, 'SIGKILL'); // отдельная группа процессов (detached)
+  } catch {
+    try { process.kill(pid, 'SIGKILL'); } catch { /* уже завершён */ }
+  }
+}
+
+// при выходе сервера браузеры не должны остаться висеть
+const alive = new Set();
+process.once('exit', () => { for (const r of alive) killTree(r.proc?.pid); });
+
+export class GpuRunner {
+  threads = 1;
+  where = 'видеокарта';
+  closed = false;
+  job = null;
+  chain = Promise.resolve();
+
+  async start({ timeoutMs = 60000 } = {}) {
+    const exe = findBrowser();
+    if (!exe) throw new Error(process.env.BROWSER_PATH ? `нет браузера по пути BROWSER_PATH: ${process.env.BROWSER_PATH}` : 'не найден Chrome / Edge / Chromium / Brave (путь можно указать в BROWSER_PATH)');
+    try {
+      await this.#serve();
+      const hello = new Promise((resolve, reject) => { this.onHello = resolve; this.onStartFail = reject; });
+      this.dir = fs.mkdtempSync(path.join(os.tmpdir(), 'trading-gpu-'));
+      const args = [
+        '--headless=new', `--user-data-dir=${this.dir}`,
+        '--no-first-run', '--no-default-browser-check', '--disable-extensions', '--disable-component-extensions-with-background-pages',
+        '--disable-sync', '--disable-component-update', '--disable-default-apps', '--disable-background-networking',
+        '--mute-audio', '--password-store=basic', '--use-mock-keychain',
+        '--ignore-gpu-blocklist', '--enable-gpu', '--enable-webgl', '--enable-gpu-rasterization',
+        '--disable-background-timer-throttling', '--disable-renderer-backgrounding', '--disable-backgrounding-occluded-windows',
+        '--disable-features=Translate,MediaRouter,OptimizationHints',
+        ...(process.getuid?.() === 0 ? ['--no-sandbox'] : []),
+        `http://127.0.0.1:${this.port}/gpu-worker.html?token=${this.token}`,
+      ];
+      this.proc = spawn(exe, args, { stdio: 'ignore', detached: process.platform !== 'win32', windowsHide: true });
+      alive.add(this);
+      this.exited = new Promise((r) => this.proc.once('exit', r));
+      this.proc.once('error', (e) => this.onStartFail?.(e));
+      this.proc.once('exit', (code) => {
+        alive.delete(this);
+        this.onStartFail?.(new Error(`браузер завершился (код ${code})`));
+        this.#failJob(new Error('браузер завершился'));
+      });
+      let timer;
+      const h = await Promise.race([hello, new Promise((_, rej) => { timer = setTimeout(() => rej(new Error('браузер не ответил за минуту')), timeoutMs); })]).finally(() => clearTimeout(timer));
+      this.onStartFail = null;
+      if (!h.webgl) throw new Error('WebGL недоступен');
+      if (SOFTWARE.test(h.renderer || '')) throw new Error(`нет видеокарты, программная отрисовка: ${h.renderer}`);
+      if (h.backend !== 'webgl') throw new Error(`TensorFlow.js не включил WebGL${h.error ? `: ${h.error}` : ''}`);
+      if (!h.float32) throw new Error('видеокарта не умеет считать в 32-битных числах');
+      this.renderer = h.renderer;
+      this.where = `видеокарта: ${gpuName(h.renderer)}`;
+      return this;
+    } catch (e) {
+      await this.close();
+      throw e;
+    }
+  }
+
+  // Служебный мини-сервер: страница обучения, общий код модели, tfjs из node_modules и WebSocket
+  async #serve() {
+    this.token = crypto.randomBytes(16).toString('hex');
+    const app = express();
+    const file = (url, p) => app.get(url, (req, res) => res.type(path.extname(p)).sendFile(p));
+    file('/gpu-worker.html', path.join(HERE, 'gpu-worker.html'));
+    file('/gpu/gpu-worker.js', path.join(HERE, 'gpu-worker.js'));
+    file('/gpu/transformer-core.js', path.join(HERE, 'transformer-core.js'));
+    file('/gpu/linalg.js', path.join(HERE, 'linalg.js'));
+    app.use('/tf', express.static(path.join(ROOT, 'node_modules/@tensorflow/tfjs/dist')));
+    this.server = http.createServer(app);
+    this.wss = new WebSocketServer({ server: this.server, path: '/gpu-ws', maxPayload: 1 << 30 });
+    this.wss.on('connection', (ws, req) => {
+      if (new URL(req.url, 'http://x').searchParams.get('token') !== this.token || this.ws) { ws.close(); return; }
+      this.ws = ws;
+      ws.on('message', (data, isBinary) => this.#onMessage(data, isBinary));
+      ws.on('close', () => { this.ws = null; this.#failJob(new Error('связь с браузером потеряна')); });
+    });
+    this.wss.on('error', () => {});
+    await new Promise((resolve, reject) => {
+      this.server.once('error', reject);
+      this.server.listen(0, '127.0.0.1', () => { this.port = this.server.address().port; resolve(); });
+    });
+  }
+
+  #onMessage(data, isBinary) {
+    if (!isBinary) {
+      const m = JSON.parse(String(data));
+      if (m.type === 'hello') { this.onHello?.(m); this.onHello = null; return; }
+      const job = this.job;
+      if (!job || m.id !== job.id) return;
+      if (m.type === 'progress') job.onProgress?.(m);
+      else if (m.type === 'error') { this.job = null; job.reject(m.cancelled || this.closed ? new Error('Отменено') : new Error(m.error)); }
+      return;
+    }
+    const m = unpack(data);
+    const job = this.job;
+    if (!job || m.id !== job.id) return;
+    this.job = null;
+    const preds = new Map();
+    Array.from(m.us).forEach((u, k) => preds.set(u, m.flat.subarray(k * job.N, (k + 1) * job.N)));
+    job.resolve({ preds, info: { ...m.info, device: this.where } });
+  }
+
+  #failJob(e) {
+    const job = this.job;
+    if (!job) return;
+    this.job = null;
+    job.reject(this.closed ? new Error('Отменено') : e);
+  }
+
+  get backlog() { return this.pending || 0; }
+
+  // Окна — строго по очереди (видеокарта одна)
+  submit(input, us, cfg, { onProgress } = {}) {
+    this.pending = (this.pending || 0) + 1;
+    const run = () => new Promise((resolve, reject) => {
+      if (this.closed || !this.ws) { reject(new Error(this.closed ? 'Отменено' : 'связь с браузером потеряна')); return; }
+      this.job = { id: crypto.randomUUID(), N: input.N, onProgress, resolve, reject };
+      this.ws.send(pack({ id: this.job.id, input, us: Int32Array.from(us), cfg }));
+    });
+    const p = this.chain.then(run, run).finally(() => { this.pending--; this.touch?.(); });
+    this.chain = p.catch(() => {});
+    return p;
+  }
+
+  // Отмена — просто закрываем браузер
+  cancel() { this.close(); }
+
+  async close() {
+    if (this.closed) return;
+    this.closed = true;
+    this.#failJob(new Error('Отменено'));
+    this.onStartFail = null;
+    if (this.proc && this.proc.exitCode === null) {
+      killTree(this.proc.pid);
+      await Promise.race([this.exited, new Promise((r) => setTimeout(r, 5000))]);
+    }
+    alive.delete(this);
+    try { this.wss?.close(); } catch { /* уже закрыт */ }
+    for (const c of this.wss?.clients || []) c.terminate();
+    await new Promise((r) => (this.server?.listening ? this.server.close(() => r()) : r()));
+    if (this.dir) fs.rm(this.dir, { recursive: true, force: true, maxRetries: 10, retryDelay: 300 }, () => {});
+  }
+}
+
+// Общий браузер для прогноза «сейчас» и живой проверки: закрывается после 10 минут простоя
+let shared = null, lastFail = null;
+const IDLE_MS = 10 * 60000;
+export async function sharedGpu() {
+  if (shared) {
+    const r = await shared;
+    if (!r.closed && r.ws) return r;
+    shared = null;
+  }
+  // недавно не получилось — не запускаем браузер на каждый прогноз заново
+  if (lastFail && Date.now() - lastFail.at < IDLE_MS) throw lastFail.error;
+  shared = new GpuRunner().start().catch((e) => { shared = null; lastFail = { at: Date.now(), error: e }; throw e; });
+  const r = await shared;
+  let timer = null;
+  r.touch = () => {
+    clearTimeout(timer);
+    timer = setTimeout(() => { if (!r.backlog) { r.close(); if (shared) shared.then((x) => { if (x === r) shared = null; }); } }, IDLE_MS);
+    timer.unref();
+  };
+  r.touch();
+  return r;
+}