neuroalpha 0.2.0 → 0.3.12

package/server/model/metrics.js

@@ -1,3 +1,4 @@
+// Copyright (c) 2026 Roman A. Perepelkin. Licensed under the MIT License.
 import { round } from '../util.js';
 
 const MSK = 3 * 3600000;

package/server/model/models.js

@@ -1,3 +1,4 @@
+// Copyright (c) 2026 Roman A. Perepelkin. Licensed under the MIT License.
 import { eigenSym, ridgeSolve, matrix, spearman, kmeans } from './linalg.js';
 import { BAR_INTERVAL } from './dataset.js';
 
@@ -19,11 +20,13 @@ for (const k of KINDS) for (const s of SCALES) for (const b of BETAS) HEADS.push
 // 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 }) {
+export function buildFold(ds, { trainStart, testStart, testEnd, H, embedDim, textWeight = 0, profiles = null, multiHorizon = false }) {
   const { tokens, mret, T } = ds;
   const N = tokens.length;
+  const Hfast = Math.max(2, Math.round(H * 0.6));
+  const Hslow = Math.round(H * 1.4);
   const lo = Math.max(1, trainStart - FEATURE_WARMUP);
-  const hi = Math.min(T, testEnd + H + 2);
+  const hi = Math.min(T, testEnd + (multiHorizon ? Hslow : H) + 2);
   const W = hi - lo;
 
   // чувствительность к рынку и обычный размах — только по окну обучения
@@ -80,20 +83,35 @@ export function buildFold(ds, { trainStart, testStart, testEnd, H, embedDim, tex
     }
   });
   // цель: остаточное (без рынка) движение, которое реально можно получить: решение на закрытии свечи t,
-  // вход по цене открытия t+1, выход по цене открытия t+1+H
+  // вход по цене открытия t+1, выход по цене открытия t+1+H (в режиме multiHorizon — взвешенная траектория 0.6H / 1.0H / 1.4H)
   const { mopen } = ds;
   const yz = new Float64Array(W * N), yraw = new Float64Array(W * N), yok = new Uint8Array(W);
+  const invFast = 1 / Math.sqrt(Hfast), invMid = 1 / Math.sqrt(H), invSlow = 1 / Math.sqrt(Hslow);
   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);
+    const mMid = Math.log(mb / ma);
+    const hasMulti = multiHorizon && (t + 1 + Hslow < T) && mopen[t + 1 + Hfast] > 0 && mopen[t + 1 + Hslow] > 0;
+    const mFast = hasMulti ? Math.log(mopen[t + 1 + Hfast] / ma) : 0;
+    const mSlow = hasMulti ? Math.log(mopen[t + 1 + Hslow] / ma) : 0;
     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 opn = tokens[i].open;
+      const a = opn[t + 1], b = opn[t + 1 + H];
+      const rMid = a > 0 && b > 0 ? Math.log(b / a) - beta[i] * mMid : 0;
+      yraw[u * N + i] = rMid;
+      const sig = sigma[i];
+      const zMid = Math.max(-8, Math.min(8, (rMid / sig) * invMid));
+      if (hasMulti && a > 0 && opn[t + 1 + Hfast] > 0 && opn[t + 1 + Hslow] > 0) {
+        const rFast = Math.log(opn[t + 1 + Hfast] / a) - beta[i] * mFast;
+        const rSlow = Math.log(opn[t + 1 + Hslow] / a) - beta[i] * mSlow;
+        const zFast = Math.max(-8, Math.min(8, (rFast / sig) * invFast));
+        const zSlow = Math.max(-8, Math.min(8, (rSlow / sig) * invSlow));
+        yz[u * N + i] = 0.25 * zFast + 0.50 * zMid + 0.25 * zSlow;
+      } else {
+        yz[u * N + i] = zMid;
+      }
     }
   }
 
@@ -196,7 +214,7 @@ export function buildFold(ds, { trainStart, testStart, testEnd, H, embedDim, tex
     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 };
+  return { N, lo, hi, W, trainStart, testStart, testEnd, H, Hfast, Hslow, multiHorizon, beta, sigma, z, has, liq, X, yz, yraw, yok, emb, embN, cos, eigenvalues: eigVals, macro };
 }
 
 // Ликвидная акция: сделки хотя бы в 15 из последних 20 свечей
@@ -205,7 +223,8 @@ 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); }
+  const maxH = f.multiHorizon ? f.Hslow : f.H;
+  for (let t = f.trainStart + FEATURE_WARMUP; t < f.testStart - maxH - 1; t++) { const u = t - f.lo; if (f.yok[u]) us.push(u); }
   return us;
 };
 
@@ -386,19 +405,10 @@ 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')));
+// Какие модели обучать: три базовые модели
+export const modelNames = () => Object.keys(MODELS);
 
 // Объяснение прогноза «внимания»: вклад каждого соседа в прогноз акции j
 export function explainAttention(m, f, u, j, top = 3) {

package/server/model/profiles.js

@@ -1,3 +1,4 @@
+// Copyright (c) 2026 Roman A. Perepelkin. Licensed under the MIT License.
 import { kvGet, kvSet } from '../db.js';
 import { ensureVocab } from './vocab.js';
 import { chatStream, extractJson, isLlmEnabled } from '../llm/client.js';

package/server/model/research.js

@@ -1,3 +1,4 @@
+// Copyright (c) 2026 Roman A. Perepelkin. Licensed under the MIT License.
 import { normalizeParams } from '../settings.js';
 import { computeReport, downsample, buildPeriods } from './metrics.js';
 import { round } from '../util.js';
@@ -18,9 +19,7 @@ const MAX_CONCURRENT_RESEARCH = 1;
 const tick = () => new Promise((r) => setImmediate(r));
 
 // Ключевые параметры для сравнения исследований (включая capital — он влияет на рубли)
-// transformerParallel сюда не входит: параллельное обучение даёт тот же результат
-const TF_KEYS = ['transformerEpochs', 'transformerStride', 'transformerGpu'];
-const REUSE_KEYS = ['modelAutoAdapt', 'modelType', 'modelHorizon', 'modelMinEdge', 'modelExitRatio', 'modelMinHoldHours', 'modelTopK', 'modelAllocMode', 'modelDirection', 'modelMarketFilter', 'modelShortFeePct', 'modelTrainDays', 'modelHistoryDays', 'modelEmbedDim', 'modelUseMacro', 'modelUseDividends', 'modelTextWeight', 'modelUseTransformer', ...TF_KEYS, 'commissionPct', 'slippagePct', 'oosPct', 'capital'];
+const REUSE_KEYS = ['modelAutoAdapt', 'modelType', 'modelHorizon', 'modelMinEdge', 'modelExitRatio', 'modelTopK', 'modelAllocMode', 'modelDirection', 'modelMarketFilter', 'modelShortFeePct', 'modelTrainDays', 'modelHistoryDays', 'modelEmbedDim', 'modelUseMacro', 'modelUseDividends', 'modelTextWeight', 'commissionPct', 'slippagePct', 'oosPct', 'capital'];
 
 // Фильтр падающего рынка: индекс Мосбиржи в среднесрочном нисходящем тренде (ниже уровня 10 торговых дней назад)
 // или в сильном локальном обвале (ниже уровня дня и 3 дней назад на >1%)
@@ -35,14 +34,13 @@ export function isMarketDown(ds, t) {
 }
 
 // Версия обработки данных: при её смене прежние прогоны не считаются «такими же» (у старых её нет).
-// 3 — затухающий карантин autoAdapt, полушаговое сопровождение сделок и адаптивная балансировка по режиму рынка
-const DATA_VERSION = 3;
+// 7 — мульти-горизонтное обучение (0.6H / 1.0H / 1.4H) + взвешивание слота по силе сигнала (Conviction Sizing) в Авто-режиме
+const DATA_VERSION = 7;
 
-// у старых исследований новых настроек нет — для них действуют умолчания;
-// настройки трансформера важны, только если он участвует
+const AUTO_LOCKED = { modelHorizon: 2.5, modelMinEdge: 2.5, modelExitRatio: 0.95 };
 function reuseParamsKey(params) {
-  const tfOn = modelNames({ ...strategyDefaults, ...params }).includes('transformer');
-  return JSON.stringify([params._data ?? 0, ...REUSE_KEYS.map((k) => (TF_KEYS.includes(k) && !tfOn ? strategyDefaults[k] : params[k] ?? strategyDefaults[k]))]);
+  const autoOn = (params.modelAutoAdapt ?? strategyDefaults.modelAutoAdapt) !== false;
+  return JSON.stringify([params._data ?? 0, ...REUSE_KEYS.map((k) => (autoOn && k in AUTO_LOCKED ? AUTO_LOCKED[k] : (params[k] ?? strategyDefaults[k])))]);
 }
 
 function findReusableRun(params) {
@@ -143,7 +141,11 @@ const fmtDay = (ts) => new Date(ts + MSK).toISOString().slice(0, 10).split('-').
 
 async function run(runId, p, state) {
   const emit = (m) => hub.emit({ type: 'research:progress', runId, ...m });
-  const H = barsFromHours(p.modelHorizon); // горизонт в свечах по 10 минут
+  const autoAdapt = p.modelAutoAdapt !== false;
+  const effHorizon = autoAdapt ? 2.5 : p.modelHorizon;
+  const effMinEdge = autoAdapt ? 2.5 : p.modelMinEdge;
+  const H = barsFromHours(effHorizon); // горизонт в свечах по 10 минут
+  const maxH = autoAdapt ? Math.round(H * 1.4) : H;
   const tillTs = Date.now();
   const researchFrom = tillTs - p.modelHistoryDays * DAY;
   const fromTs = researchFrom - Math.ceil(p.modelTrainDays * 1.5 + 20) * DAY;
@@ -151,7 +153,7 @@ async function run(runId, p, state) {
   emit({ stage: 'data', pct: 0, text: 'Загружаем словарь рынка (состав индекса широкого рынка)…' });
   const ds = await loadDataset({
     fromTs, tillTs, useMacro: p.modelUseMacro, useDividends: p.modelUseDividends, signal: state.ctrl.signal,
-    onProgress: (x) => emit({ stage: 'data', pct: Math.round((x.done / x.total) * 100), text: `Загружаем цены: ${x.done} из ${x.total}. Первый раз — до 10 минут` }),
+    onProgress: (x) => emit({ stage: 'data', pct: Math.round((x.done / x.total) * 100), text: `Загружаем цены: ${x.done} из ${x.total} (${x.symbol})…`, symbol: x.symbol, done: x.done, total: x.total }),
   });
   const { tokens, T, timeline } = ds;
   const N = tokens.length;
@@ -172,13 +174,8 @@ async function run(runId, p, state) {
     });
   }
 
-  // три базовые модели всегда; трансформер — если включён или торгует
+  // три базовые модели всегда сравниваются между собой
   const names = modelNames(p);
-  const useTf = names.includes('transformer');
-  const tfMod = useTf ? await import('./transformer.js') : null;
-  const tfCfg = useTf ? tfMod.transformerCfg(p) : null;
-  const tfInfo = useTf ? { folds: [], device: 'процессор', threads: 1, note: '' } : null;
-  const fmtTfInfo = ({ backend, device, ...i }) => ({ ...i, valIc: i.valIc === null ? null : round(i.valIc, 4), scale: round(i.scale, 4) });
   const preds = Object.fromEntries(names.map((n) => [n, new Map()])); // t -> Float64Array(N)
   const yraw = new Map(); // t -> Float64Array(N)
   const sigmaAt = new Map(); // t -> обычный размах акций в этом окне обучения
@@ -187,118 +184,75 @@ async function run(runId, p, state) {
   const folds = Math.ceil((T - H - firstTest) / testLen);
   let fi = 0;
 
-  // Трансформер при параллельном обучении (или на видеокарте) — отдельный исполнитель: окна уходят ему
-  // по мере построения (конвейер), базовые модели тем временем считаются здесь как обычно
-  let tfRunner = null, tfOpened = false, tfDone = 0, mainText = null, tfFail = null;
-  const tfJobs = []; // { lo, pr } по порядку окон
-  const tfFrac = new Map(); // окно → доля пройденных эпох
-  const progress = () => {
-    const where = tfRunner.threads > 1 ? `потоков: ${tfRunner.threads}` : tfRunner.where;
-    const tfText = `Трансформер: обучено ${tfDone} из ${folds} окон (${where})`;
-    const part = [...tfFrac.values()].reduce((s, v) => s + v, 0);
-    emit({ stage: 'sim', pct: Math.min(99, Math.round(((tfDone + part) / folds) * 100)), text: mainText ? `${mainText} · ${tfText}` : tfText });
-  };
-  const onAbort = () => tfRunner?.cancel();
-  state.ctrl.signal.addEventListener('abort', onAbort, { once: true });
-
-  try {
-    while (testStart < T - H - 2) {
-      if (state.cancelled) throw new Error('Отменено');
-      const testEnd = Math.min(testStart + testLen, T - H - 2);
-      const trainStart = Math.max(FEATURE_WARMUP + H + 2, testStart - trainLen);
-      mainText = `Обучение ${fi + 1} из ${folds}: учимся до ${fmtDay(timeline[testStart])}, прогнозируем до ${fmtDay(timeline[testEnd - 1])}`;
-      if (tfRunner) progress();
-      else emit({ stage: 'sim', pct: Math.round((fi / folds) * 100), text: mainText });
+  while (testStart < T - maxH - 2) {
+    if (state.cancelled) throw new Error('Отменено');
+    const testEnd = Math.min(testStart + testLen, T - maxH - 2);
+    const trainStart = Math.max(FEATURE_WARMUP + maxH + 2, testStart - trainLen);
+    const mainText = `Обучение ${fi + 1} из ${folds}: учимся до ${fmtDay(timeline[testStart])}, прогнозируем до ${fmtDay(timeline[testEnd - 1])}`;
+    await tick();
+    const f = buildFold(ds, { trainStart, testStart, testEnd, H, embedDim: p.modelEmbedDim, textWeight: p.modelTextWeight, profiles, multiHorizon: autoAdapt });
+    const fitted = {};
+    for (const n of names) {
+      fitted[n] = await MODELS[n].fit(f);
       await tick();
-      const f = buildFold(ds, { trainStart, testStart, testEnd, H, embedDim: p.modelEmbedDim, textWeight: p.modelTextWeight, profiles });
-      // исполнитель открываем на первом окне: для числа потоков нужен объём данных окна
-      if (useTf && !tfOpened && (p.transformerParallel || p.transformerGpu)) {
-        tfOpened = true;
-        const { openTransformerRunner } = await import('./transformer-pool.js');
-        const r = await openTransformerRunner({ gpu: p.transformerGpu, parallel: p.transformerParallel, jobs: folds, bytes: tfMod.inputBytes(tfMod.transformerInput(f)) });
-        tfRunner = r.runner;
-        tfInfo.note = r.note;
-        if (r.note) emit({ stage: 'sim', pct: Math.round((fi / folds) * 100), text: `Трансформер: ${r.note}` });
-        if (tfRunner) { tfInfo.device = tfRunner.where; tfInfo.threads = tfRunner.threads; }
-        if (state.cancelled) throw new Error('Отменено');
-      }
-      const fitNames = tfRunner ? names.filter((n) => n !== 'transformer') : names;
-      const fitted = {};
-      const foldText = `Обучение ${fi + 1} из ${folds}`;
-      try {
-        for (const n of fitNames) {
-          // трансформер учится по эпохам: прогресс и отмена — между батчами
-          const opts = n === 'transformer' ? {
-            cfg: tfCfg,
-            isCancelled: () => state.cancelled,
-            onProgress: (x) => emit({ stage: 'sim', pct: Math.round(((fi + (x.epoch - 1) / x.epochs) / folds) * 100), text: `${foldText}: трансформер, эпоха ${x.epoch}…` }),
-          } : undefined;
-          fitted[n] = await MODELS[n].fit(f, opts);
-          await tick();
-          if (state.cancelled) throw new Error('Отменено');
-        }
-        const us = [];
-        for (let t = testStart; t < testEnd; t++) if (f.yok[t - f.lo]) us.push(t - f.lo);
-        // тяжёлые модели (трансформер) предсказывают сразу пачкой моментов
-        const many = Object.fromEntries(fitNames.filter((n) => MODELS[n].predictMany).map((n) => [n, MODELS[n].predictMany(fitted[n], f, us)]));
-        for (const [k, u] of us.entries()) {
-          if ((k & 511) === 0) {
-            if (state.cancelled) throw new Error('Отменено');
-            await tick();
-          }
-          const t = f.lo + u;
-          for (const n of fitNames) preds[n].set(t, many[n] ? many[n].get(u) : MODELS[n].predict(fitted[n], f, u));
-          yraw.set(t, Float64Array.from(f.yraw.subarray(u * N, u * N + N)));
-          sigmaAt.set(t, f.sigma);
-        }
-        if (tfRunner) {
-          // массивы окна уходят исполнителю без копирования: базовые модели этого окна уже посчитаны
-          const k = fi;
-          const pr = tfRunner.submit(tfMod.transformerInput(f), us, tfCfg, {
-            transfer: true,
-            onProgress: (x) => { tfFrac.set(k, (x.epoch - 1) / x.epochs); progress(); },
-          }).then((r) => { tfDone++; tfFrac.delete(k); progress(); return r; });
-          pr.catch((e) => { tfFail = tfFail || e; });
-          tfJobs.push({ lo: f.lo, pr });
-        }
-      } finally {
-        // веса нейросети освобождаем после каждого окна (и при отмене)
-        for (const n of fitNames) if (fitted[n]?.dispose) {
-          const m = fitted[n];
-          m.dispose();
-          if (tfInfo && n === 'transformer') tfInfo.folds.push(fmtTfInfo({ ...m.info, tensors: m.tf.memory().numTensors }));
-          delete fitted[n];
-        }
-      }
-      // снимок карты рынка на начало месяца прогноза
-      const snap = mapSnapshot(f);
-      const pts = alignTo(prevPts, snap.pts);
-      const cl = matchClusters(prevCl, snap.clusters, 8);
-      snapshots.push({ ts: timeline[testStart], pts: pts.map(([x, y]) => [round(x, 3), round(y, 3)]), cl });
-      prevPts = pts; prevCl = cl;
-      lastFold = f; lastModels = fitted;
-      testStart = testEnd;
-      fi++;
-      // не копим очередь окон (память): ждём, пока у исполнителя не освободится место
-      while (tfRunner && tfRunner.backlog > tfRunner.threads) {
+      if (state.cancelled) throw new Error('Отменено');
+    }
+    const us = [];
+    for (let t = testStart; t < testEnd; t++) if (f.yok[t - f.lo]) us.push(t - f.lo);
+    for (const [k, u] of us.entries()) {
+      if ((k & 511) === 0) {
         if (state.cancelled) throw new Error('Отменено');
-        if (tfFail) throw tfFail;
-        await new Promise((r) => setTimeout(r, 200));
+        await tick();
       }
+      const t = f.lo + u;
+      for (const n of names) preds[n].set(t, MODELS[n].predict(fitted[n], f, u));
+      yraw.set(t, Float64Array.from(f.yraw.subarray(u * N, u * N + N)));
+      sigmaAt.set(t, f.sigma);
     }
-    if (tfRunner) {
-      mainText = null;
-      progress();
-      const res = await Promise.all(tfJobs.map((j) => j.pr));
-      tfJobs.forEach((j, k) => {
-        for (const [u, pr] of res[k].preds) preds.transformer.set(j.lo + u, pr);
-        tfInfo.folds.push(fmtTfInfo(res[k].info));
-      });
+    // снимок карты рынка на начало месяца прогноза
+    const snap = mapSnapshot(f);
+    const pts = alignTo(prevPts, snap.pts);
+    const cl = matchClusters(prevCl, snap.clusters, 8);
+    const ptsRound = pts.map(([x, y]) => [round(x, 3), round(y, 3)]);
+    snapshots.push({ ts: timeline[testStart], pts: ptsRound, cl });
+    prevPts = pts; prevCl = cl;
+    lastFold = f; lastModels = fitted;
+
+    // живая телеметрия шага обучения для инфографики в интерфейсе
+    const attM = fitted.attention;
+    let foldIc = null;
+    if (preds.attention) {
+      let icS = 0, icK = 0;
+      for (let t = testStart; t < testEnd; t += Math.max(1, Math.floor(H / 2))) {
+        const pr = preds.attention.get(t), y = yraw.get(t);
+        if (!pr || !y) continue;
+        const ok = [...pr.keys()].filter((i) => tokens[i].liq[t] >= LIQ_MIN);
+        if (ok.length >= 10) { icS += spearman(ok.map((i) => pr[i]), ok.map((i) => y[i])); icK++; }
+      }
+      if (icK > 0) foldIc = round(icS / icK, 4);
     }
-  } finally {
-    state.ctrl.signal.removeEventListener('abort', onAbort);
-    // потоки и браузер не переживают исследование
-    if (tfRunner) await tfRunner.close();
+    const liveViz = {
+      fold: fi + 1,
+      folds,
+      tokens: N,
+      horizon: effHorizon,
+      trainFrom: timeline[trainStart],
+      testFrom: timeline[testStart],
+      testTill: timeline[testEnd - 1],
+      periodFrom: timeline[Math.max(0, firstTest - trainLen)],
+      periodTill: timeline[T - 1],
+      foldIc,
+      pts: ptsRound,
+      cl,
+      ...(fi === 0 ? { symbols: tokens.map((tk) => tk.symbol) } : {}),
+      ...(attM ? {
+        heads: HEADS.map((h, i) => ({ label: h.label, coef: round(attM.coef[i], 4) })),
+        self: [round(attM.coef[HEADS.length], 4), round(attM.coef[HEADS.length + 1], 4), round(attM.coef[HEADS.length + 2], 4)],
+      } : {}),
+    };
+    emit({ stage: 'sim', pct: Math.round(((fi + 1) / folds) * 100), text: mainText, viz: liveViz });
+    testStart = testEnd;
+    fi++;
   }
 
   emit({ stage: 'sim', pct: 100, text: 'Считаем результаты…' });
@@ -309,9 +263,7 @@ async function run(runId, p, state) {
   // ---------- портфель из лучших прогнозов: покупки, продажи без покупки, пары «нейтрально к рынку» ----------
   const K = p.modelTopK;
   const dir = p.modelDirection;
-  const autoAdapt = p.modelAutoAdapt !== false;
   const exitRatio = Number(p.modelExitRatio ?? 0.5);
-  const minHoldBars = p.modelMinHoldHours > 0 ? barsFromHours(p.modelMinHoldHours) : 0;
   const mktFilter = p.modelMarketFilter === 'ma';
   const invVol = p.modelAllocMode === 'invvol';
   const realCost = (p.commissionPct + p.slippagePct) / 100;
@@ -359,9 +311,9 @@ async function run(runId, p, state) {
     // Самообучение правил по прошлым закрытым сделкам (временный карантин «акций-убийц» с затуханием и авто-калибровка порога выхода)
     const stockPnl = new Float64Array(N), stockCnt = new Float64Array(N);
     const stockAllowed = (i) => !autoAdapt || !(stockCnt[i] >= 3 && stockPnl[i] < -0.012);
-    let curExitRatio = autoAdapt ? 0.75 : exitRatio;
+    let curExitRatio = autoAdapt ? 0.95 : exitRatio;
     const stepBars = autoAdapt ? Math.max(2, Math.floor(H / 2)) : H;
-    const maxSlotWeight = dir === 'long' ? Math.min(0.45, Math.max(1 / K, 1.35 / K)) : (dir === 'neutral' ? Math.min(0.22, 1 / (2 * K)) : Math.min(0.30, 1.2 / (2 * K)));
+    const maxSlotWeight = dir === 'long' ? Math.min(0.45, Math.max(1 / K, 1.35 / K)) : (dir === 'neutral' ? Math.min(0.25, 1 / (2 * K)) : Math.min(0.35, 1.4 / (2 * K)));
 
     const closePos = (i, h, t, end, why) => {
       const exitPrice = px(i, t);
@@ -397,16 +349,15 @@ async function run(runId, p, state) {
       let order, entries;
       if (dir !== 'long') {
         const edge = (i) => pr[i] * sg[i] * Math.sqrt(H);
-        const need = p.modelMinEdge * 2 * realCost;
+        const need = effMinEdge * 2 * realCost;
         const exitNeed = need * curExitRatio;
         const earlyExitNeed = need * 0.35;
-        // держим позицию, пока ожидаемое движение выше порога выхода (на первой половине горизонта — мягкий порог, чтобы не резать сделку от шума)
+        // держим позицию, пока ожидаемое движение выше порога выхода (первые два полушага — мягкий порог, чтобы не резать сделку от шума)
         for (const [i, h] of [...held]) {
           const e = edge(i);
           const barsHeld = tIn - h.entryT;
-          const lock = minHoldBars > 0 && barsHeld < minHoldBars && (h.side === 'short' ? e <= 0 : e >= 0);
-          const req = autoAdapt && barsHeld < H ? earlyExitNeed : exitNeed;
-          if ((!lock && !(h.side === 'long' ? e > req : e < -req)) || !liquid(i, t)) closePos(i, h, tIn, false, 'Прогноз ослаб');
+          const req = autoAdapt && barsHeld <= 2 * stepBars ? earlyExitNeed : exitNeed;
+          if (!(h.side === 'long' ? e > req : e < -req) || !liquid(i, t)) closePos(i, h, tIn, false, 'Прогноз ослаб');
         }
         const needL = autoAdapt && dir === 'longshort' && bear ? need * 1.25 : need;
         const needS = autoAdapt && dir === 'longshort' ? (bear ? need * 0.90 : need * 1.25) : need;
@@ -432,28 +383,25 @@ async function run(runId, p, state) {
           ...candL.slice(0, Math.max(0, nL)).map((i) => [i, 'long', edge(i)]),
           ...candS.slice(0, Math.max(0, nS)).map((i) => [i, 'short', edge(i)]),
         ];
-      } else if (p.modelMinEdge > 0) {
+      } else if (effMinEdge > 0) {
         // ожидаемое движение (в долях) = прогноз × обычный размах × √H; входим, только если оно окупает сделку
         const edge = (i) => pr[i] * sg[i] * Math.sqrt(H);
-        const need = p.modelMinEdge * 2 * realCost;
+        const need = effMinEdge * 2 * realCost;
         const exitNeed = need * curExitRatio;
         const earlyExitNeed = need * 0.35;
         for (const [i, h] of [...held]) {
           const e = edge(i);
           const barsHeld = tIn - h.entryT;
-          const lock = minHoldBars > 0 && barsHeld < minHoldBars && e >= 0;
-          const req = autoAdapt && barsHeld < H ? earlyExitNeed : exitNeed;
-          if ((!lock && !(e > req)) || !liquid(i, t)) closePos(i, h, tIn, false);
+          const req = autoAdapt && barsHeld <= 2 * stepBars ? earlyExitNeed : exitNeed;
+          if (!(e > req) || !liquid(i, t)) closePos(i, h, tIn, false);
         }
         const free = K - held.size;
         const needL = autoAdapt && bear ? need * 1.25 : need;
         const cand = mktDown ? [] : [...pr.keys()].filter((i) => !held.has(i) && stockAllowed(i) && liquid(i, t) && edge(i) > needL).sort((a, b) => pr[b] - pr[a]).slice(0, Math.max(0, free));
         order = [...held.keys(), ...cand];
       } else {
-        const keepLocked = [...held].filter(([i, h]) => minHoldBars > 0 && (tIn - h.entryT) < minHoldBars && liquid(i, t) && pr[i] >= 0).map(([i]) => i);
-        const lockedSet = new Set(keepLocked);
-        const cand = mktDown ? [] : [...pr.keys()].filter((i) => !lockedSet.has(i) && stockAllowed(i) && pr[i] > 0 && liquid(i, t)).sort((a, b) => pr[b] - pr[a]).slice(0, Math.max(0, K - keepLocked.length));
-        order = [...keepLocked, ...cand];
+        const cand = mktDown ? [] : [...pr.keys()].filter((i) => stockAllowed(i) && pr[i] > 0 && liquid(i, t)).sort((a, b) => pr[b] - pr[a]).slice(0, K);
+        order = cand;
         const next = new Set(order);
         for (const [i, h] of [...held]) if (!next.has(i)) closePos(i, h, tIn, false);
       }
@@ -467,9 +415,12 @@ async function run(runId, p, state) {
       }
       const usedStart = [...held.values()].reduce((s, h) => s + h.alloc, 0);
       let avail = Math.max(0, equity * 0.99 - usedStart);
+      const needEdge = effMinEdge * 2 * realCost;
       for (let idx = 0; idx < newEntries.length; idx++) {
         const [i, side, edgeAt] = newEntries[idx];
-        const baseAlloc = autoAdapt ? Math.min(equity * maxSlotWeight, avail / Math.max(1, newEntries.length - idx)) : Math.min(equity / slots, avail / Math.max(1, newEntries.length - idx));
+        const effEdge = edgeAt !== null ? Math.abs(edgeAt) : (sg ? Math.abs(pr[i] * sg[i] * Math.sqrt(H)) : 0);
+        const conv = autoAdapt && needEdge > 0 && effEdge > 0 ? Math.min(1.20, Math.max(0.85, 0.80 + 0.20 * (effEdge / needEdge))) : 1;
+        const baseAlloc = autoAdapt ? Math.min(equity * maxSlotWeight * conv, avail / Math.max(1, newEntries.length - idx)) : Math.min(equity / slots, avail / Math.max(1, newEntries.length - idx));
         let alloc = baseAlloc;
         if (invVol && avgInv > 0 && sg[i] > 0) {
           const w = Math.max(0.4, Math.min(1.8, (1 / sg[i]) / avgInv));
@@ -499,7 +450,7 @@ async function run(runId, p, state) {
   function tradeRec(name, i, h, t, exitPrice, pnl, commission, borrow, end = false, why = '') {
     const heldMin = (t - h.entryT) * BAR_INTERVAL; // минуты
     const short = h.side === 'short';
-    const hz = round(p.modelHorizon, 2);
+    const hz = round(effHorizon, 2);
     const label = MODELS[name].label;
     const reasonEntry = dir === 'long' ? `Модель «${label}»: акция среди ${K} лучших прогнозов на ${hz} ч вперёд`
       : short ? `Модель «${label}»: продажа: ожидаемо слабее рынка на ${Math.abs(h.expectedPct)}% за ${hz} ч`
@@ -638,9 +589,6 @@ async function run(runId, p, state) {
     heads, self, macroHeads,
     map: { snapshots, eigenvalues: lastFold.eigenvalues.map((v) => round(v, 3)) },
     neighbors,
-    // трансформер: число весов и ход обучения по окнам (эпохи, совпадение на проверке)
-    // где шло обучение: «процессор» или «видеокарта: <название>»; потоков — сколько окон обучалось одновременно
-    ...(tfInfo ? { transformer: { params: tfInfo.folds[0]?.params ?? null, epochs: tfCfg.epochs, stride: tfCfg.stride, device: tfInfo.device, threads: tfInfo.threads, ...(tfInfo.note ? { note: tfInfo.note } : {}), folds: tfInfo.folds } } : {}),
   });
   finishRun(runId, { metrics: report, equity: downsample(results[chosen].sim.curve) });
   return report;
@@ -704,12 +652,12 @@ async function runStabilityLoop(targetId, runRow, st) {
     const { tokens, T, timeline } = ds;
     const N = tokens.length, bpd = ds.barsPerDay;
     const trainLen = Math.round(p.modelTrainDays * bpd), testLen = Math.round(20 * bpd);
-    const chosen = p.modelType === 'transformer' ? 'attention' : (p.modelType in MODELS ? p.modelType : 'attention');
+    const chosen = p.modelType in MODELS ? p.modelType : 'attention';
     const realCost = (p.commissionPct + p.slippagePct) / 100;
     const K = p.modelTopK, dir = p.modelDirection, slots = dir === 'long' ? K : 2 * K;
     const autoAdapt = p.modelAutoAdapt !== false;
+    const effMinEdge = autoAdapt ? 2.5 : p.modelMinEdge;
     const exitRatio = Number(p.modelExitRatio ?? 0.5);
-    const minHoldBars = p.modelMinHoldHours > 0 ? barsFromHours(p.modelMinHoldHours) : 0;
     const mktFilter = p.modelMarketFilter === 'ma', invVol = p.modelAllocMode === 'invvol';
     const liquid = (i, t) => tokens[i].liq[t] >= LIQ_MIN && tokens[i].open[t + 1] > 0;
     const tsOf = (t) => timeline[Math.min(t, T - 1)];
@@ -730,17 +678,18 @@ async function runStabilityLoop(targetId, runRow, st) {
       const histDays = Math.max(120, Math.min(1100, p.modelHistoryDays + sh));
       const resFrom = periodTill - histDays * DAY;
       let testStart = Math.max(timeline.findIndex((t) => t >= resFrom), trainLen + 10);
-      const folds = Math.max(1, Math.ceil((T - H - testStart) / testLen));
+      const maxH = autoAdapt ? Math.round(H * 1.4) : H;
+      const folds = Math.max(1, Math.ceil((T - maxH - testStart) / testLen));
       let fi = 0;
       const preds = new Map(), sigmaAt = new Map();
-      while (testStart < T - H - 2) {
+      while (testStart < T - maxH - 2) {
         if (st.cancelled) throw new Error('Отменено');
-        const testEnd = Math.min(testStart + testLen, T - H - 2);
-        const trainStart = Math.max(FEATURE_WARMUP + H + 2, testStart - trainLen);
+        const testEnd = Math.min(testStart + testLen, T - maxH - 2);
+        const trainStart = Math.max(FEATURE_WARMUP + maxH + 2, testStart - trainLen);
         const pct = Math.min(99, 10 + Math.round(((si + fi / folds) / shifts.length) * 90));
         emitStab({ pct, text: `Проверка устойчивости: сдвиг ${si + 1} из ${shifts.length} (${shLabel}), шаг ${fi + 1} из ${folds}…` });
         await tick();
-        const f = buildFold(ds, { trainStart, testStart, testEnd, H, embedDim: p.modelEmbedDim, textWeight: p.modelTextWeight, profiles });
+        const f = buildFold(ds, { trainStart, testStart, testEnd, H, embedDim: p.modelEmbedDim, textWeight: p.modelTextWeight, profiles, multiHorizon: autoAdapt });
         const m = await MODELS[chosen].fit(f);
         for (let t = testStart; t < testEnd; t++) {
           const u = t - f.lo;
@@ -762,9 +711,9 @@ async function runStabilityLoop(targetId, runRow, st) {
       const countSide = (side) => [...held.values()].filter((h) => h.side === side).length;
       const stockPnl = new Float64Array(N), stockCnt = new Float64Array(N);
       const stockAllowed = (i) => !autoAdapt || !(stockCnt[i] >= 3 && stockPnl[i] < -0.012);
-      const curExitRatio = autoAdapt ? 0.75 : exitRatio;
+      const curExitRatio = autoAdapt ? 0.95 : exitRatio;
       const stepBars = autoAdapt ? Math.max(2, Math.floor(H / 2)) : H;
-      const maxSlotWeight = dir === 'long' ? Math.min(0.45, Math.max(1 / K, 1.35 / K)) : (dir === 'neutral' ? Math.min(0.22, 1 / (2 * K)) : Math.min(0.30, 1.2 / (2 * K)));
+      const maxSlotWeight = dir === 'long' ? Math.min(0.45, Math.max(1 / K, 1.35 / K)) : (dir === 'neutral' ? Math.min(0.25, 1 / (2 * K)) : Math.min(0.35, 1.4 / (2 * K)));
       const closePos = (i, h, t) => {
         const exitPrice = px(i, t);
         const gross = h.side === 'short' ? h.alloc * (1 - exitPrice / h.entryPrice) : h.alloc * (exitPrice / h.entryPrice - 1);
@@ -788,14 +737,13 @@ async function runStabilityLoop(targetId, runRow, st) {
         const bear = isMarketDown(ds, t);
         const mktDown = mktFilter && dir !== 'neutral' && bear;
         const edge = (i) => pr[i] * sg[i] * Math.sqrt(H);
-        const need = p.modelMinEdge * 2 * realCost, exitNeed = need * curExitRatio, earlyExitNeed = need * 0.35;
+        const need = effMinEdge * 2 * realCost, exitNeed = need * curExitRatio, earlyExitNeed = need * 0.35;
         let order, entries;
         if (dir !== 'long') {
           for (const [i, h] of [...held]) {
             const e = edge(i), barsHeld = tIn - h.entryT;
-            const lock = minHoldBars > 0 && barsHeld < minHoldBars && (h.side === 'long' ? e >= 0 : e <= 0);
-            const req = autoAdapt && barsHeld < H ? earlyExitNeed : exitNeed;
-            if ((!lock && !(h.side === 'long' ? e > req : e < -req)) || !liquid(i, t)) closePos(i, h, tIn);
+            const req = autoAdapt && barsHeld <= 2 * stepBars ? earlyExitNeed : exitNeed;
+            if (!(h.side === 'long' ? e > req : e < -req) || !liquid(i, t)) closePos(i, h, tIn);
           }
           const needL = autoAdapt && dir === 'longshort' && bear ? need * 1.25 : need;
           const needS = autoAdapt && dir === 'longshort' ? (bear ? need * 0.90 : need * 1.25) : need;
@@ -812,26 +760,23 @@ async function runStabilityLoop(targetId, runRow, st) {
             }
             nL = Math.max(0, pairs - countSide('long')); nS = Math.max(0, pairs - countSide('short'));
           }
-          entries = [...candL.slice(0, Math.max(0, nL)).map((i) => [i, 'long']), ...candS.slice(0, Math.max(0, nS)).map((i) => [i, 'short'])];
-        } else if (p.modelMinEdge > 0) {
+          entries = [...candL.slice(0, Math.max(0, nL)).map((i) => [i, 'long', edge(i)]), ...candS.slice(0, Math.max(0, nS)).map((i) => [i, 'short', edge(i)])];
+        } else if (effMinEdge > 0) {
           for (const [i, h] of [...held]) {
             const e = edge(i), barsHeld = tIn - h.entryT;
-            const lock = minHoldBars > 0 && barsHeld < minHoldBars && e >= 0;
-            const req = autoAdapt && barsHeld < H ? earlyExitNeed : exitNeed;
-            if ((!lock && !(e > req)) || !liquid(i, t)) closePos(i, h, tIn);
+            const req = autoAdapt && barsHeld <= 2 * stepBars ? earlyExitNeed : exitNeed;
+            if (!(e > req) || !liquid(i, t)) closePos(i, h, tIn);
           }
           const needL = autoAdapt && bear ? need * 1.25 : need;
           const cand = mktDown ? [] : [...pr.keys()].filter((i) => !held.has(i) && stockAllowed(i) && liquid(i, t) && edge(i) > needL).sort((a, b) => pr[b] - pr[a]).slice(0, Math.max(0, K - held.size));
           order = [...held.keys(), ...cand];
         } else {
-          const keepLocked = [...held].filter(([i, h]) => minHoldBars > 0 && (tIn - h.entryT) < minHoldBars && liquid(i, t) && pr[i] >= 0).map(([i]) => i);
-          const lockedSet = new Set(keepLocked);
-          const cand = mktDown ? [] : [...pr.keys()].filter((i) => !lockedSet.has(i) && stockAllowed(i) && pr[i] > 0 && liquid(i, t)).sort((a, b) => pr[b] - pr[a]).slice(0, Math.max(0, K - keepLocked.length));
-          order = [...keepLocked, ...cand];
+          const cand = mktDown ? [] : [...pr.keys()].filter((i) => stockAllowed(i) && pr[i] > 0 && liquid(i, t)).sort((a, b) => pr[b] - pr[a]).slice(0, K);
+          order = cand;
           const next = new Set(order);
           for (const [i, h] of [...held]) if (!next.has(i)) closePos(i, h, tIn);
         }
-        if (!entries) entries = order.map((i) => [i, 'long']);
+        if (!entries) entries = order.map((i) => [i, 'long', null]);
         const newEntries = entries.filter(([i]) => !held.has(i));
         let avgInv = 0;
         if (invVol && newEntries.length && sg) {
@@ -842,8 +787,10 @@ async function runStabilityLoop(targetId, runRow, st) {
         const usedStart = [...held.values()].reduce((s, h) => s + h.alloc, 0);
         let avail = Math.max(0, equity * 0.99 - usedStart);
         for (let idx = 0; idx < newEntries.length; idx++) {
-          const [i, side] = newEntries[idx];
-          const baseAlloc = autoAdapt ? Math.min(equity * maxSlotWeight, avail / Math.max(1, newEntries.length - idx)) : Math.min(equity / slots, avail / Math.max(1, newEntries.length - idx));
+          const [i, side, edgeAt] = newEntries[idx];
+          const effEdge = edgeAt !== null && edgeAt !== undefined ? Math.abs(edgeAt) : (sg ? Math.abs(pr[i] * sg[i] * Math.sqrt(H)) : 0);
+          const conv = autoAdapt && need > 0 && effEdge > 0 ? Math.min(1.20, Math.max(0.85, 0.80 + 0.20 * (effEdge / need))) : 1;
+          const baseAlloc = autoAdapt ? Math.min(equity * maxSlotWeight * conv, avail / Math.max(1, newEntries.length - idx)) : Math.min(equity / slots, avail / Math.max(1, newEntries.length - idx));
           let alloc = baseAlloc;
           if (invVol && avgInv > 0 && sg[i] > 0) {
             const w = Math.max(0.4, Math.min(1.8, (1 / sg[i]) / avgInv));

package/server/model/vocab.js

@@ -1,3 +1,4 @@
+// Copyright (c) 2026 Roman A. Perepelkin. Licensed under the MIT License.
 import { kvGet, kvSet } from '../db.js';
 
 // «Словарь» модели: акции индекса широкого рынка МосБиржи (MOEXBMI, ~100 бумаг)

package/server/news/index.js

@@ -1,3 +1,4 @@
+// Copyright (c) 2026 Roman A. Perepelkin. Licensed under the MIT License.
 import { db } from '../db.js';
 import { hub } from '../hub.js';
 import { getSettings } from '../settings.js';