neuroalpha 0.2.0 → 0.3.13

package/server/model/forecast.js

@@ -1,12 +1,13 @@
+// Copyright (c) 2026 Roman A. Perepelkin. All rights reserved. Proprietary software.
 import { normalizeParams } from '../settings.js';
 import { round, DAY, fmtBarMsk } from '../util.js';
-import { loadDataset, barsFromHours, BAR_MS, BAR_INTERVAL } from './dataset.js';
-import { buildFold, MODELS, HEADS, LIQ_MIN, FEATURE_WARMUP, explainAttention, mapSnapshot } from './models.js';
+import { loadDataset, barsFromHours, BAR_MS } from './dataset.js';
+import { buildFold, MODELS, HEADS, SCALES, BETAS, LIQ_MIN, FEATURE_WARMUP, explainAttention, mapSnapshot } from './models.js';
 import { loadProfiles } from './profiles.js';
 import { isMarketDown } from './research.js';
 import { newsForSymbols } from '../news/index.js';
 
-let cache = null;
+let baseState = null; // { key, trainedAt, ds, last, r, snap, prevExpMap, prevRankMap, lastTickResult, lastTickAt }
 const inflight = new Map();
 
 export const lastClosedIndex = (ds, now = Date.now()) => {
@@ -15,42 +16,131 @@ export const lastClosedIndex = (ds, now = Date.now()) => {
   return last;
 };
 
+// Быстрое получение живых цен Мосбиржи (TQBR + IMOEX) за 1 лёгкий запрос (~80 мс)
+async function fetchLiveMoexSnapshot() {
+  try {
+    const [rShares, rIdx] = await Promise.all([
+      fetch('https://iss.moex.com/iss/engines/stock/markets/shares/boards/TQBR/securities.json?iss.meta=off&iss.only=marketdata&marketdata.columns=SECID,LAST,MARKETPRICE,LCURRENTPRICE,VALTODAY', { signal: AbortSignal.timeout(6000) }),
+      fetch('https://iss.moex.com/iss/engines/stock/markets/index/boards/SNDX/securities/IMOEX.json?iss.meta=off&iss.only=marketdata&marketdata.columns=SECID,CURRENTVALUE,LASTVALUE', { signal: AbortSignal.timeout(6000) }).catch(() => null),
+    ]);
+    if (!rShares.ok) return null;
+    const j = await rShares.json();
+    const cols = j.marketdata?.columns || [];
+    const iSec = cols.indexOf('SECID');
+    const iLast = cols.indexOf('LAST');
+    const iMkt = cols.indexOf('MARKETPRICE');
+    const iCur = cols.indexOf('LCURRENTPRICE');
+    const prices = new Map();
+    for (const row of j.marketdata?.data || []) {
+      const sym = row[iSec];
+      const px = Number(row[iLast] || row[iMkt] || row[iCur] || 0);
+      if (sym && px > 0) prices.set(sym, px);
+    }
+    let imoexPrice = 0;
+    if (rIdx?.ok) {
+      const ji = await rIdx.json().catch(() => null);
+      const ic = ji?.marketdata?.columns || [];
+      const ir = ji?.marketdata?.data?.[0];
+      if (ir) imoexPrice = Number(ir[ic.indexOf('CURRENTVALUE')] || ir[ic.indexOf('LASTVALUE')] || 0);
+    }
+    return { prices, imoexPrice, ts: Date.now() };
+  } catch {
+    return null;
+  }
+}
+
+// Мгновенное обновление последней точки контекста u в уже обученной модели по живым котировкам (за ~2 мс)
+function applyLivePricesToFold(ds, f, u, fitted, liveSnap) {
+  if (!liveSnap?.prices?.size) return;
+  const idx = f.lo + u;
+  if (idx < 1 || idx >= ds.T) return;
+  const N = f.N;
+  const mPrev = ds.mclose?.[idx - 1] || 0;
+  const mLive = liveSnap.imoexPrice > 0 && mPrev > 0 ? Math.log(liveSnap.imoexPrice / mPrev) : ds.mret[idx];
+
+  // 1) пересчитываем z[u*N + i] по живой цене акции относительно закрытия предыдущей свечи
+  for (let i = 0; i < N; i++) {
+    const tk = ds.tokens[i];
+    const prevPx = tk.close[idx - 1];
+    const livePx = liveSnap.prices.get(tk.symbol);
+    if (livePx > 0 && prevPx > 0) {
+      const ret = Math.log(livePx / prevPx);
+      const e = ret - f.beta[i] * mLive;
+      f.z[u * N + i] = Math.max(-8, Math.min(8, e / f.sigma[i]));
+    }
+  }
+
+  // 2) пересчитываем признаки масштаба 0 (последний час) в точке u
+  const sc0 = SCALES[0];
+  const invP = 1 / Math.sqrt(sc0.len), invF = invP / 1.5;
+  const Xp0 = f.X[0][0], Xf0 = f.X[1][0];
+  for (let i = 0; i < N; i++) {
+    let sp = 0, sf = 0;
+    for (let k = 0; k < sc0.len; k++) {
+      const uk = u - k;
+      if (uk < 0) break;
+      const zk = f.z[uk * N + i];
+      sp += zk;
+      sf += zk * Math.min(4, ds.tokens[i].valRatio[f.lo + uk]);
+    }
+    Xp0[u * N + i] = sp * invP;
+    Xf0[u * N + i] = sf * invF;
+  }
+
+  // 3) пересчитываем головы внимания F[hi][u*N + j] в точке u
+  const att = fitted.attention;
+  if (att?.As && att?.F) {
+    const off = u * N;
+    for (let hi = 0; hi < HEADS.length; hi++) {
+      const h = HEADS[hi];
+      const bIdx = BETAS.findIndex((b) => b.v === h.beta);
+      const A = att.As[bIdx];
+      const X = f.X[h.kind === 'price' ? 0 : 1][h.scale];
+      const Fh = att.F[hi];
+      for (let j = 0; j < N; j++) {
+        let s = 0;
+        const row = j * N;
+        for (let i = 0; i < N; i++) s += A[row + i] * X[off + i];
+        Fh[off + j] = s;
+      }
+    }
+  }
+}
+
 // Обучение на окне, заканчивающемся свечой idx, и прогноз по этой свече.
 // Возвращает строки по всем акциям: ожидаемое движение (относительно рынка), сигнал покупки, кто влияет.
-export async function predictAt(ds, p, idx, { explain = true } = {}) {
-  const H = barsFromHours(p.modelHorizon);
+export async function predictAt(ds, p, idx, { explain = true, liveSnap = null } = {}) {
+  const autoAdapt = p.modelAutoAdapt !== false;
+  const effHorizon = autoAdapt ? 2.5 : p.modelHorizon;
+  const effMinEdge = autoAdapt ? 2.5 : p.modelMinEdge;
+  const H = barsFromHours(effHorizon);
+  const maxH = autoAdapt ? Math.round(H * 1.4) : H;
   const trainLen = Math.round(p.modelTrainDays * ds.barsPerDay);
-  const trainStart = Math.max(FEATURE_WARMUP + H + 2, idx - trainLen);
+  const trainStart = Math.max(FEATURE_WARMUP + maxH + 2, idx - trainLen);
   // «текстовая» часть карты: устойчивые описания бизнеса (профили готовятся отдельно, здесь только читаем)
   const profiles = p.modelTextWeight > 0 ? loadProfiles() : null;
-  const f = buildFold(ds, { trainStart, testStart: idx, testEnd: idx + 1, H, embedDim: p.modelEmbedDim, textWeight: p.modelTextWeight, profiles });
+  const f = buildFold(ds, { trainStart, testStart: idx, testEnd: idx + 1, H, embedDim: p.modelEmbedDim, textWeight: p.modelTextWeight, profiles, multiHorizon: autoAdapt });
   const u = idx - f.lo;
   const chosen = p.modelType in MODELS ? p.modelType : 'attention';
-  const need = ['attention', chosen];
-  // трансформер обучается здесь, только если торгует он (для сравнения — только в исследовании)
-  const list = [...new Set(explain ? [...Object.keys(MODELS).filter((n) => !MODELS[n].heavy), chosen] : need)];
+  const list = [...new Set(explain ? Object.keys(MODELS) : ['attention', chosen])];
   const fitted = {};
-  const preds = {};
   for (const n of list) {
-    if (n === 'transformer') {
-      // ~минута обучения — в отдельном потоке (или на видеокарте), чтобы сервер не замирал
-      const tm = await import('./transformer.js');
-      const { fitPredictIsolated } = await import('./transformer-pool.js');
-      const r = await fitPredictIsolated(tm.transformerInput(f), [u], tm.transformerCfg(p), { gpu: p.transformerGpu });
-      fitted[n] = { name: n, info: r.info, where: r.where };
-      preds[n] = r.preds.get(u);
-      continue;
-    }
     fitted[n] = await MODELS[n].fit(f);
+  }
+  if (liveSnap) applyLivePricesToFold(ds, f, u, fitted, liveSnap);
+  return buildPredictionRows(ds, p, idx, f, u, fitted, chosen, H, effMinEdge, autoAdapt, explain, liveSnap);
+}
+
+function buildPredictionRows(ds, p, idx, f, u, fitted, chosen, H, effMinEdge, autoAdapt, explain, liveSnap = null) {
+  const preds = {};
+  for (const n of Object.keys(fitted)) {
     preds[n] = MODELS[n].predict(fitted[n], f, u);
-    if (fitted[n].dispose) fitted[n].dispose();
   }
   const cost = (p.commissionPct + p.slippagePct) / 100;
-  const threshold = p.modelMinEdge * 2 * cost;
+  const threshold = effMinEdge * 2 * cost;
   const bear = isMarketDown(ds, idx);
-  const autoAdapt = p.modelAutoAdapt !== false;
   const dir = p.modelDirection || 'long';
-  const needL = autoAdapt && bear && dir !== 'neutral' ? threshold * 1.25 : threshold;
+  const needL = autoAdapt && bear ? threshold * 1.25 : threshold;
   const needS = autoAdapt && dir === 'longshort' ? (bear ? threshold * 0.90 : threshold * 1.25) : threshold;
   let sInv = 0, nInv = 0;
   for (let i = 0; i < ds.tokens.length; i++) if (f.sigma[i] > 0 && ds.tokens[i].liq[idx] >= LIQ_MIN) { sInv += 1 / f.sigma[i]; nInv++; }
@@ -58,8 +148,10 @@ export async function predictAt(ds, p, idx, { explain = true } = {}) {
   const rows = ds.tokens.map((tk, i) => {
     const exp = preds[chosen][i] * f.sigma[i] * Math.sqrt(H);
     const weight = avgInv > 0 && f.sigma[i] > 0 ? Math.max(0.4, Math.min(1.8, (1 / f.sigma[i]) / avgInv)) : 1;
+    const livePx = liveSnap?.prices?.get(tk.symbol) || tk.close[idx] || 0;
     const row = {
       i, symbol: tk.symbol, name: tk.name,
+      price: round(livePx, 4),
       liquid: tk.liq[idx] >= LIQ_MIN,
       expected: exp,
       expectedPct: round(exp * 100, 3),
@@ -78,9 +170,7 @@ export async function predictAt(ds, p, idx, { explain = true } = {}) {
   return { f, u, fitted, chosen, threshold, marketDown: bear, rows };
 }
 
-// Новости — только в прогнозе «сейчас»: в исторической проверке их нет (истории новостей не существует,
-// и ИИ, знающий будущее, исказил бы проверку). Строкам с новостями за последние 24 ч добавляем
-// news: { count, tone — средний взвешенный по важности, top — суть самой важной }
+// Новости — только в прогнозе «сейчас»
 function withNews(result, p) {
   const nm = p.newsEnabled ? newsForSymbols(24) : null;
   for (const r of result.rows) {
@@ -91,29 +181,104 @@ function withNews(result, p) {
   return result;
 }
 
-// Прогноз на ближайшие H часов по последней закрытой свече
+// Добавляет к каждой строке дельту ожидания (deltaPct) и смещение в рейтинге (rankDelta) относительно предыдущего замера
+function attachDeltas(rows, stateObj) {
+  const prevExp = stateObj.prevExpMap;
+  const prevRank = stateObj.prevRankMap;
+  const nextExp = new Map();
+  const nextRank = new Map();
+  let changed = false;
+
+  rows.forEach((r, idx) => {
+    const rank = idx + 1;
+    nextExp.set(r.symbol, r.expectedPct);
+    nextRank.set(r.symbol, rank);
+    if (prevExp && prevExp.has(r.symbol)) {
+      const d = round(r.expectedPct - prevExp.get(r.symbol), 3);
+      if (Math.abs(d) >= 0.001) changed = true;
+      r.deltaPct = d !== 0 ? d : (r.deltaPct || 0);
+      r.rankDelta = prevRank?.has(r.symbol) ? (prevRank.get(r.symbol) - rank) : 0;
+    } else {
+      r.deltaPct = 0;
+      r.rankDelta = 0;
+    }
+  });
+
+  if (!prevExp || changed) {
+    stateObj.prevExpMap = nextExp;
+    stateObj.prevRankMap = nextRank;
+  }
+}
+
+// Прогноз на ближайшие H часов с живым поминутным обновлением котировок (без переобучения тяжёлого окна каждую минуту)
 export async function forecastNow(input, { force = false, onProgress } = {}) {
   const p = normalizeParams(input);
-  const key = JSON.stringify([p.modelType, p.modelHorizon, p.modelTrainDays, p.modelEmbedDim, p.modelMinEdge, p.modelDirection, p.modelUseMacro, p.modelUseDividends, p.modelTextWeight, p.commissionPct, p.slippagePct, ...(p.modelType === 'transformer' ? [p.transformerEpochs, p.transformerStride, p.transformerGpu] : [])]);
-  if (!force && cache && cache.key === key && Date.now() - cache.at < 10 * 60000) return withNews(cache.result, p);
+  const autoAdapt = p.modelAutoAdapt !== false;
+  const effHorizon = autoAdapt ? 2.5 : p.modelHorizon;
+  const effMinEdge = autoAdapt ? 2.5 : p.modelMinEdge;
+  const key = JSON.stringify([autoAdapt, p.modelType, effHorizon, p.modelTrainDays, p.modelEmbedDim, effMinEdge, p.modelDirection, p.modelUseMacro, p.modelUseDividends, p.modelTextWeight, p.commissionPct, p.slippagePct]);
+
+  const now = Date.now();
+  // 1) Если с последнего живого тика прошло меньше 15 секунд и нет force — отдаём мгновенно из памяти
+  if (!force && baseState && baseState.key === key && baseState.lastTickResult && now - baseState.lastTickAt < 15000) {
+    return withNews(baseState.lastTickResult, p);
+  }
+  // 2) Если базовая модель обучена менее 10 минут назад и нет force — делаем быстрый живой пересчёт (~80 мс запрос + 2 мс математика)
+  if (!force && baseState && baseState.key === key && now - baseState.trainedAt < 10 * 60000) {
+    const liveSnap = await fetchLiveMoexSnapshot();
+    if (liveSnap) applyLivePricesToFold(baseState.ds, baseState.f, baseState.u, baseState.fitted, liveSnap);
+    const H = barsFromHours(effHorizon);
+    const r = buildPredictionRows(baseState.ds, p, baseState.last, baseState.f, baseState.u, baseState.fitted, baseState.chosen, H, effMinEdge, autoAdapt, true, liveSnap);
+    const sortedRows = r.rows.map(({ i, expected, ...x }) => ({ ...x, cluster: baseState.snap.clusters[i] })).sort((a, b) => b.expectedPct - a.expectedPct);
+    attachDeltas(sortedRows, baseState);
+    const result = {
+      ...baseState.lastTickResult,
+      at: now,
+      liveTs: liveSnap?.ts || now,
+      rows: sortedRows,
+    };
+    baseState.lastTickResult = result;
+    baseState.lastTickAt = now;
+    return withNews(result, p);
+  }
+
   if (!force && inflight.has(key)) return withNews(await inflight.get(key), p);
   const task = (async () => {
-    const now = Date.now();
-    const ds = await loadDataset({ fromTs: now - Math.ceil(p.modelTrainDays * 1.5 + 25) * DAY, tillTs: now, useMacro: p.modelUseMacro, useDividends: p.modelUseDividends, onProgress });
+    const [ds, liveSnap] = await Promise.all([
+      loadDataset({ fromTs: now - Math.ceil(p.modelTrainDays * 1.5 + 25) * DAY, tillTs: now, useMacro: p.modelUseMacro, useDividends: p.modelUseDividends, onProgress }),
+      fetchLiveMoexSnapshot(),
+    ]);
     const last = lastClosedIndex(ds, now);
-    const r = await predictAt(ds, p, last);
+    const r = await predictAt(ds, p, last, { explain: true, liveSnap });
     const snap = mapSnapshot(r.f);
+    const sortedRows = r.rows.map(({ i, expected, ...x }) => ({ ...x, cluster: snap.clusters[i] })).sort((a, b) => b.expectedPct - a.expectedPct);
+    const stateObj = baseState && baseState.key === key ? baseState : { prevExpMap: null, prevRankMap: null };
+    attachDeltas(sortedRows, stateObj);
     const result = {
       at: now,
+      liveTs: liveSnap?.ts || now,
       barTs: ds.timeline[last],
       bar: fmtBarMsk(ds.timeline[last]),
-      horizon: p.modelHorizon, direction: p.modelDirection, model: r.chosen, thresholdPct: round(r.threshold * 100, 3), marketDown: r.marketDown,
-      rows: r.rows.map(({ i, expected, ...x }) => ({ ...x, cluster: snap.clusters[i] })).sort((a, b) => b.expectedPct - a.expectedPct),
+      horizon: effHorizon, direction: p.modelDirection, model: r.chosen, thresholdPct: round(r.threshold * 100, 3), marketDown: r.marketDown,
+      rows: sortedRows,
       map: { symbols: ds.tokens.map((t) => t.symbol), names: ds.tokens.map((t) => t.name), pts: snap.pts.map(([x, y]) => [round(x, 3), round(y, 3)]), cl: snap.clusters },
       heads: HEADS.map((h, i) => ({ label: h.label, coef: round(r.fitted.attention.coef[i], 4) })),
-      ...(r.fitted.transformer ? { transformer: { device: r.fitted.transformer.where, bestEpoch: r.fitted.transformer.info.bestEpoch, epochs: r.fitted.transformer.info.epochs } } : {}),
     };
-    cache = { key, at: now, result };
+    baseState = {
+      key,
+      trainedAt: now,
+      ds,
+      last,
+      f: r.f,
+      u: r.u,
+      fitted: r.fitted,
+      chosen: r.chosen,
+      snap,
+      prevExpMap: stateObj.prevExpMap,
+      prevRankMap: stateObj.prevRankMap,
+      lastTickResult: result,
+      lastTickAt: now,
+    };
     return result;
   })().finally(() => inflight.delete(key));
   inflight.set(key, task);

package/server/model/linalg.js

@@ -1,3 +1,4 @@
+// Copyright (c) 2026 Roman A. Perepelkin. All rights reserved. Proprietary software.
 // Небольшая линейная алгебра без зависимостей: матрицы — массивы Float64Array (строки)
 
 export const matrix = (n, m) => Array.from({ length: n }, () => new Float64Array(m));