Комментарии (5)

1. 

   bambazamba

   26.05.2026 18:27

   #30023216

   Потестил опубликованный чекпоинт.

   90% output'а кортекса константа, не зависящая от входных токенов. Мотор подстроился под постоянный сдвиг от кортекса, а не под его "смысл".

   Проблема многих публикуемых комбинированных архитектур (трансформеры + hi_dim vector bottleneck "для смысла") - модель находит обходной путь. Tрансформеры делают всю работу, а bottleneck коллапсирует в константу или около того, от которой мотор формально зависит, но информации оттуда толком не получает. Но лучше перепроверьте сами, я тестил поверхностно.

   
   

   1. 

      Kamil_GR Автор

      26.05.2026 18:27

      #30023226

      Ага, скиньте, плз, описание как тестировали, пойдет и LLM описание, сюда, в личку или ТГ, как будет удобнее

      Просто при коллапсе, градиент по гейтам и сами гейты ушли бы к нулю... А если посмотреть логи, они вполне себе живы.

      Ну и 10% вполне себе влияет на мотор.

   
   

   1. 

      Kamil_GR Автор

      26.05.2026 18:27

      #30028372

      Протестировал код, который вы направили мне в личку. Спасибо большое!

      И пришел к забавным выводам, 87% константа - это маска, которую кортекс создал для гашения структурного шума трансформера. Сенсорный блок использует абсолютные позиционные эмбеддинги, на каждой позиции в окне от 0 до 63 генерируется специфический структурный шум (краевые эффекты, ритм абсолютных позиций, и т.д.). Вот их и структурные шумы самого датасета эта константа и давит через отрицательные гейты.

      Я немного расширил ваш код, вы проверяли на шуме (случайных токенах), я добавил тестирование на тексте ( с передачей стэйта):

      Веса загружены: checkpoints_vortex_hybrid/vortex_26_4_final_step_31000.pt gate_fast=-1.8633, gate_slow=-2.5850

      ================================================== РЕЖИМ ТЕСТИРОВАНИЯ: NOISE

      [A] Baseline (Полная модель) CE = 8.8635, Acc@10 = 8.65%

      [B] Ablation (Врата = 0, Кортекс отключен) CE = 15.7139, Acc@10 = 0.97% (Delta: +6.8504)

      [MODULATION STATS] mod_total = 85.6461 mod_mean (const) = 81.0749 energy: constant/total = 0.9083 (90.8%) position variance: mean=1.3537

      ================================================== РЕЖИМ ТЕСТИРОВАНИЯ: REAL

      [A] Baseline (Полная модель) CE = 1.6128, Acc@10 = 90.27%

      [B] Ablation (Врата = 0, Кортекс отключен) CE = 7.1746, Acc@10 = 35.22% (Delta: +5.5618)

      [MODULATION STATS] mod_total = 90.9642 mod_mean (const) = 83.9554 energy: constant/total = 0.8727 (87.3%) position variance: mean=2.1394

      То есть большая часть усилий кортекса уходило на очистку сигнала для трансформера. И только 10-13% на непосредственно модуляцию. Обратите внимание, как падает точность при работе с текстом в момент отключения кортекса. На шуме сравнение конечно некорректно. Забавна разница в константе при тесте на шуме и тексте - похоже для текста кортекс отдает больше переменных сигналов, что снижает долю константы.

      После этого у меня появилось несколько интересных идей для развития проекта. Да и сам факт, что большая часть усилий кортекса уходит на очистку от суеты самого трансформера очень интересен.

      Код который я использовал:

      Скрытый текст

      """
      Ablation test v2: TriuneVortex 26.4 (Noise vs Real Text)
      """
      import os, sys, glob, math
      from pathlib import Path
      import numpy as np
      import torch
      import torch.nn as nn
      import torch.nn.functional as F
      
      torch.manual_seed(42)
      device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
      
      # --- КОНФИГУРАЦИЯ ---
      VOCAB_SIZE = 1024
      D_MODEL = 512
      SEQ_LEN = 64
      CHUNK_SIZE = 4
      CORE_DIM = 128
      SLOW_UPDATE_INTERVAL = 4
      NUM_CHUNKS = SEQ_LEN // CHUNK_SIZE
      
      CKPT_PATH = "checkpoints_vortex_hybrid/vortex_26_4_final_step_31000.pt"
      DATA_PATH = r"C:\Users\admin\Desktop\PGHM\PHOA78\data\datasets\fineweb10B_sp1024"
      TRAIN_FILES_MASK = os.path.join(DATA_PATH, "fineweb_train_*.bin")
      
      # --- ЗАГРУЗЧИК РЕАЛЬНЫХ ДАННЫХ ---
      def load_data_shard(file: Path) -> torch.Tensor:
          h = np.fromfile(file, dtype="<i4", count=256)
          t = np.fromfile(file, dtype="<u2", count=int(h[2]), offset=256*4)
          t = np.clip(t, 0, VOCAB_SIZE - 1)
          return torch.from_numpy(t.astype(np.int64, copy=False))
      
      class StatefulTokenLoader:
          def __init__(self, pattern: str, batch_size: int, seq_len: int):
              self.files = [Path(p) for p in sorted(glob.glob(pattern))]
              self.batch_size = batch_size
              self.seq_len = seq_len
              self.file_idx = 0
              if not self.files:
                  print("ВНИМАНИЕ: Файлы датасета не найдены. Режим REAL упадет с ошибкой.")
                  return
              self._load_next_shard()
      
          def _load_next_shard(self):
              tokens = load_data_shard(self.files[self.file_idx])
              num_tokens = len(tokens)
              tokens_per_stream = num_tokens // self.batch_size
              truncated_len = tokens_per_stream * self.batch_size
              self.data = tokens[:truncated_len].view(self.batch_size, tokens_per_stream)
              self.pos = 0
              self.max_pos = tokens_per_stream - (self.seq_len + 1)
      
          def next_batch(self):
              if self.pos >= self.max_pos:
                  self.file_idx = (self.file_idx + 1) % len(self.files)
                  self._load_next_shard()
              chunk = self.data[:, self.pos : self.pos + self.seq_len + 1]
              self.pos += self.seq_len
              x = chunk[:, :-1].to(device, dtype=torch.long)
              y = chunk[:, 1:].to(device, dtype=torch.long)
              return x, y
      
      # --- АРХИТЕКТУРА ---
      class TriuneVortex(nn.Module):
          def __init__(self):
              super().__init__()
              self.embed = nn.Embedding(VOCAB_SIZE, D_MODEL)
              self.pos_embed = nn.Embedding(SEQ_LEN, D_MODEL)
      
              encoder_layer_front = nn.TransformerEncoderLayer(
                  d_model=D_MODEL, nhead=8, dim_feedforward=D_MODEL * 4,
                  batch_first=True, activation="gelu", norm_first=True,
              )
              encoder_layer_back = nn.TransformerEncoderLayer(
                  d_model=D_MODEL, nhead=8, dim_feedforward=D_MODEL * 4,
                  batch_first=True, activation="gelu", norm_first=True,
              )
              self.transformer_front = nn.TransformerEncoder(encoder_layer_front, num_layers=2)
              self.transformer_back = nn.TransformerEncoder(encoder_layer_back, num_layers=3)
      
              self.cortex_in = nn.Linear(D_MODEL, CORE_DIM)
              self.fast_rnn = nn.GRU(input_size=CORE_DIM + 2, hidden_size=CORE_DIM, batch_first=True)
              self.slow_rnn = nn.GRU(input_size=CORE_DIM, hidden_size=CORE_DIM, batch_first=True)
              self.bridge_fast = nn.Linear(CORE_DIM, D_MODEL)
              self.bridge_slow = nn.Linear(CORE_DIM, D_MODEL)
              self.gate_fast = nn.Parameter(torch.zeros(1))
              self.gate_slow = nn.Parameter(torch.zeros(1))
              self.future_proj = nn.Linear(CORE_DIM * 2, D_MODEL)
              self.motor_monitor = nn.Linear(CORE_DIM * 2, 1)
              self.head = nn.Linear(D_MODEL, VOCAB_SIZE, bias=False)
      
          def forward(self, x, targets=None, core_state=None, gate_override=None, mod_override=None, return_internals=False):
              batch_size, seq_len = x.size()
              num_chunks = seq_len // CHUNK_SIZE
      
              positions = torch.arange(0, seq_len, dtype=torch.long, device=x.device).unsqueeze(0)
              emb_x = self.embed(x) + self.pos_embed(positions)
              causal_mask = torch.triu(torch.full((seq_len, seq_len), float("-inf"), device=x.device), diagonal=1)
      
              mid_l2_seq = self.transformer_front(emb_x, mask=causal_mask)
      
              with torch.no_grad():
                  logits_front = self.head(mid_l2_seq)
                  probs_front = F.softmax(logits_front, dim=-1)
                  log_probs_front = F.log_softmax(logits_front, dim=-1)
                  H_norm = (-(probs_front * log_probs_front).sum(-1)) / math.log(VOCAB_SIZE)
                  Top1_front = probs_front.max(-1).values
      
              mid_l2_chunks = mid_l2_seq.view(batch_size, num_chunks, CHUNK_SIZE, D_MODEL)
              l2_context = mid_l2_chunks.mean(dim=2)
              core_input = self.cortex_in(l2_context.detach())
      
              H_chunk = H_norm.view(batch_size, num_chunks, CHUNK_SIZE).mean(dim=2).unsqueeze(-1)
              Top1_chunk = Top1_front.view(batch_size, num_chunks, CHUNK_SIZE).mean(dim=2).unsqueeze(-1)
              mode_signal = torch.cat([H_chunk, Top1_chunk], dim=-1)
      
              fast_rnn_input = torch.cat([core_input, mode_signal], dim=-1)
      
              if core_state is not None:
                  h_fast_hidden, h_slow_hidden = core_state
              else:
                  h_fast_hidden = torch.zeros(1, batch_size, CORE_DIM, device=x.device, dtype=emb_x.dtype)
                  h_slow_hidden = torch.zeros(1, batch_size, CORE_DIM, device=x.device, dtype=emb_x.dtype)
      
              fast_out, h_fast_hidden = self.fast_rnn(fast_rnn_input, h_fast_hidden)
              slow_input = fast_out[:, 0::SLOW_UPDATE_INTERVAL, :]
              slow_out, h_slow_hidden = self.slow_rnn(slow_input, h_slow_hidden)
      
              h_fast_transposed = h_fast_hidden.transpose(0, 1)
              fast_states_chunk = torch.cat([h_fast_transposed, fast_out[:, :-1, :]], dim=1)
      
              S = slow_out
              h_slow_transposed = h_slow_hidden.transpose(0, 1)
              slow_states_chunk = torch.cat([
                  h_slow_transposed,
                  S[:, 0:1, :].repeat(1, 4, 1),
                  S[:, 1:2, :].repeat(1, 4, 1),
                  S[:, 2:3, :].repeat(1, 4, 1),
                  S[:, 3:4, :].repeat(1, 3, 1),
              ], dim=1)
      
              fast_states_seq = fast_states_chunk.repeat_interleave(CHUNK_SIZE, dim=1)
              slow_states_seq = slow_states_chunk.repeat_interleave(CHUNK_SIZE, dim=1)
      
              mod_fast = self.bridge_fast(fast_states_seq) * self.gate_fast
              mod_slow = self.bridge_slow(slow_states_seq) * self.gate_slow
      
              if gate_override is not None:
                  mod_fast = mod_fast * 0
                  mod_slow = mod_slow * 0
      
              if mod_override is not None:
                  mod_fast = mod_override
                  mod_slow = torch.zeros_like(mod_fast)
      
              modulated_mid_seq = mid_l2_seq + mod_fast + mod_slow
      
              final_l2_seq = self.transformer_back(modulated_mid_seq, mask=causal_mask)
              logits_seq = self.head(final_l2_seq)
      
              loss_ce, acc10 = None, None
              if targets is not None:
                  loss_ce = F.cross_entropy(logits_seq.view(-1, VOCAB_SIZE), targets.reshape(-1))
                  with torch.no_grad():
                      _, top10 = torch.topk(logits_seq.view(-1, VOCAB_SIZE), 10, dim=-1)
                      acc10 = (top10 == targets.reshape(-1).unsqueeze(1)).sum().item() / targets.numel() * 100
      
              internals = None
              if return_internals:
                  internals = {
                      "mid_l2_seq": mid_l2_seq.detach(),
                      "mod_fast": mod_fast.detach(),
                      "mod_slow": mod_slow.detach(),
                      "modulated": modulated_mid_seq.detach(),
                  }
      
              next_core_state = (h_fast_hidden.detach(), h_slow_hidden.detach())
              return loss_ce, acc10, internals, next_core_state
      
      # --- ЗАГЛУШКИ ТЕСТИРОВЩИКА ---
      class PositionalBias(nn.Module):
          def __init__(self):
              super().__init__()
              self.bias = nn.Parameter(torch.zeros(1, SEQ_LEN, D_MODEL))
          def forward(self, mid_l2_seq):
              return self.bias.expand(mid_l2_seq.shape[0], -1, -1)
      
      class ChunkBias(nn.Module):
          def __init__(self):
              super().__init__()
              self.bias = nn.Parameter(torch.zeros(1, NUM_CHUNKS, D_MODEL))
          def forward(self, mid_l2_seq):
              return self.bias.repeat_interleave(CHUNK_SIZE, dim=1).expand(mid_l2_seq.shape[0], -1, -1)
      
      # --- ИНСТРУМЕНТЫ ОЦЕНКИ ---
      @torch.no_grad()
      def evaluate(model, mode="noise", loader=None, n_batches=100, batch_size=64, gate_override=None, mod_override_fn=None):
          total_ce = 0.0
          total_acc = 0.0
          core_state = None # Инициализация стейта для сквозного прохода
      
          for _ in range(n_batches):
              if mode == "noise":
                  x = torch.randint(0, VOCAB_SIZE, (batch_size, SEQ_LEN + 1), device=device)
                  inp, tgt = x[:, :-1], x[:, 1:]
                  core_state = None # На шуме стейт сбрасывается (амнезия)
              else:
                  inp, tgt = loader.next_batch()
      
              mod_ov = None
              if mod_override_fn is not None:
                  _, _, internals, _ = model(inp, core_state=core_state, return_internals=True)
                  mod_ov = mod_override_fn(internals["mid_l2_seq"])
      
              loss_ce, acc10, _, core_state = model(inp, targets=tgt, core_state=core_state, gate_override=gate_override, mod_override=mod_ov)
              total_ce += loss_ce.item()
              total_acc += acc10
      
          return total_ce / n_batches, total_acc / n_batches
      
      @torch.no_grad()
      def measure_modulation_stats(model, mode="noise", loader=None, n_batches=50, batch_size=64):
          all_mods = []
          all_mids = []
          core_state = None
      
          for _ in range(n_batches):
              if mode == "noise":
                  inp = torch.randint(0, VOCAB_SIZE, (batch_size, SEQ_LEN), device=device)
                  core_state = None
              else:
                  inp, _ = loader.next_batch()
      
              _, _, internals, core_state = model(inp, core_state=core_state, return_internals=True)
              mod = internals["mod_fast"] + internals["mod_slow"]
              all_mods.append(mod.cpu())
              all_mids.append(internals["mid_l2_seq"].cpu())
      
          mods = torch.cat(all_mods, dim=0)
          mids = torch.cat(all_mids, dim=0)
          mod_mean = mods.mean(dim=0)
          mod_residual = mods - mod_mean.unsqueeze(0)
      
          mean_sq = mod_mean.norm(dim=-1).pow(2).mean().item()
          total_sq = mods.norm(dim=-1).pow(2).mean().item()
          constant_frac = mean_sq / total_sq if total_sq > 0 else 0.0
      
          print(f"    ||mod_total||        = {mods.norm(dim=-1).mean():.4f}")
          print(f"    ||mod_mean|| (const) = {mod_mean.norm(dim=-1).mean():.4f}")
          print(f"    energy: constant/total = {constant_frac:.4f} ({constant_frac*100:.1f}%)")
          
          pos_var = mods.var(dim=0).mean(dim=-1)
          print(f"    position variance: mean={pos_var.mean():.4f}")
      
      def run_tests_for_mode(model, mode, loader):
          print(f"\n" + "="*50)
          print(f" РЕЖИМ ТЕСТИРОВАНИЯ: {mode.upper()}")
          print("="*50)
          
          print("\n[A] Baseline (Полная модель)")
          ce_a, acc_a = evaluate(model, mode=mode, loader=loader)
          print(f"    CE = {ce_a:.4f}, Acc@10 = {acc_a:.2f}%")
      
          print("\n[B] Ablation (Врата = 0, Кортекс отключен)")
          ce_b, acc_b = evaluate(model, mode=mode, loader=loader, gate_override=True)
          print(f"    CE = {ce_b:.4f}, Acc@10 = {acc_b:.2f}% (Delta: {ce_b-ce_a:+.4f})")
      
          print("\n[MODULATION STATS]")
          measure_modulation_stats(model, mode=mode, loader=loader)
      
      def main():
          if not os.path.exists(CKPT_PATH):
              print(f"Файл {CKPT_PATH} не найден.")
              return
      
          sd = torch.load(CKPT_PATH, map_location=device, weights_only=True)
          model = TriuneVortex().to(device)
          model.load_state_dict(sd)
          model.eval()
      
          print(f"Веса загружены: {CKPT_PATH}")
          print(f"gate_fast={sd['gate_fast'].item():.4f}, gate_slow={sd['gate_slow'].item():.4f}")
          
          loader = None
          if glob.glob(TRAIN_FILES_MASK):
              loader = StatefulTokenLoader(TRAIN_FILES_MASK, batch_size=64, seq_len=SEQ_LEN)
          
          # Запуск на белом шуме
          run_tests_for_mode(model, mode="noise", loader=None)
          
          # Запуск на реальных данных
          if loader:
              run_tests_for_mode(model, mode="real", loader=loader)
      
      if __name__ == "__main__":
          main()

      UPD: появилась идея, что это ещё и семантический сдвиг (в зависмости от домена), но это было бы чересчур хорошо, потом протестирую на разного типа текстах.

1. 

   proxy3d

   26.05.2026 18:27

   #30023856

   Рекомендую обратить внимание на "оживший" не так давно подход PMax. Исторически Predictability Maximization (PMAX) у Шмидхубера и последующих интерпретаций. Это не совсем привычные предсказания, а скорее про два конкурирующих требования:

   1. Predictability (предсказуемость)

   части представления должны быть объяснимы / предсказываемы из других частей

   2. Discriminability (различимость)

   представление не должно схлопываться в константу и должно сохранять структуру различий

   Так как то что описали выше про бутылочное горлышка, как раз центральная проблема PMAX/JEPA класса:

   Если максимизировать только предсказание, то всё схлопнется в константу

   Если максимизировать только различимость, то получаем шум вместо структуры.

   Поэтому PMAX фактически баланс 2 сил. Система должна быть максимально предсказуемой внутри структуры, но максимально различающей между структурами.

   В Jepa одна из проблем, что система находит лазейку и старается все свети к константе. Изначально PMAX (разработанный еще в 90-ых) как раз был про то, что принцип построения представлений, которые одновременно максимально предсказуемы из контекста и максимально информативны. Не знаю, как проще объяснить. Может на видео будет понятней.

   То есть это две конкурирующих потока, один заставляет систему лучше предсказывать, а второй чтобы предсказания отличались.

   Недавно на одном видео попадался разбор, где пытались как раз это объединить в рамках разных архитектурных подходов. Там еще PINN, но ее можно опустить в видео.

   Суть в том, чтобы система не только искала как лучше предсказать (а то будет константа или 0), а одновременно стремилась к разнообразию. Может это может в рамках комментария выше про Мотор подстроился под постоянный сдвиг от кортекса, а не под его "смысл".

   
   

   1. 

      Kamil_GR Автор

      26.05.2026 18:27

      #30028484

      Может это может в рамках комментария выше про Мотор подстроился под постоянный сдвиг от кортекса, а не под его "смысл".

      Скорее всего нет, выше я ответил на комментарий. Очень высока вероятность того, что кортекс накладывает маску на структурные шумы трансформера и датасета. Чистый трансформер такого уровня бпб не добивается.

      Сейчас уже обучается следующая версия кода, там расширен кортекс и поменял аддитивное сложение на сигмоиду... По идее бегство кортекса в константу должно быть минимизировано. Смотрю..