"""Маленький GPT (символьный) с RoPE и подключаемыми «дешёвыми» слоями. Смешиватели токенов по слоям (строка cfg.mixers, по символу на слой): a — causal self-attention с RoPE (база) c — FreqConv: причинная depthwise-свёртка по K предыдущим токенам, входы взвешены по частоте токена (idf: редкие символы весят больше) — «conv-attention» без матрицы T×T s — token shift: смесь текущего и предыдущего вектора (как в RWKV), почти бесплатно Статистические добавки (считаются по train-части, без утечки val): ngram_prior=N — к логитам добавляется log P(next | N-1 предыдущих) из таблиц счётчиков (порядки 2..N), веса смешивания порядков предсказывает сеть по позиции. На обучении счётчики leave-one-out (минус сам пример), иначе модель научится слепо доверять таблице, которая «видела ответ». ngram_embed=N — хэш-эмбеддинги n-грамм (2..N) на входе: контекст символа как lookup ctx_count — сколько раз текущий символ уже встречался в контексте (бакеты) -> эмбеддинг ReForm — рекуррентный по глубине Transformer с головой остановки и латентным вектором (класс внизу). """ import contextlib import math from dataclasses import dataclass import torch import torch.nn as nn import torch.nn.functional as F @dataclass class Cfg: vocab: int = 65 ctx: int = 256 n_layer: int = 6 d: int = 384 heads: int = 6 mlp: float = 4.0 mixers: str = "" # "" = все слои attention act: str = "gelu" # gelu | relu2 qk_norm: bool = False conv_k: int = 8 ngram_prior: int = 0 ngram_embed: int = 0 ngram_buckets: int = 1 << 14 ctx_count: bool = False ctx_ngram: int = 0 # «статистическая индукционная голова»: суффиксы длины 1..N внутри контекста tie: bool = False emb_std: float = 0.0 # >0: эмбеддинги из N(0, emb_std) (при tie иначе стартовые логиты ~N(0, d)) dropout: float = 0.0 # ReForm (рекуррентная глубина, см. класс ReForm) prelude: int = 2 # уникальные блоки до цикла core: int = 2 # блоки ядра, которое повторяется r_max раз (общие веса) r_max: int = 3 # максимум повторов на обучении ponder_beta: float = 0.01 # цена одного повтора (нат/токен) в лоссе — давит на раннюю остановку latent_noise: float = 0.0 # шум латентного вектора s0 на обучении depth_norm: bool = False # свои масштабы RMSNorm ядра на каждом повторе (relaxed recursion, ~0 весов) latent_gate: bool = False # гейт обновления латентного вектора: s ← s + z⊙(core(...) − s), как в GRU think_slots: int = 0 # расширенная мысль: m слотов памяти на токен (чтение/запись по адресу) think_shift: bool = False # сдвиг мысли: смесь с мыслью предыдущего токена на той же глубине think_conv: str = "" # свёртка мысли по времени (ThoughtConv): conv | gconv | ms | ema think_k: int = 4 # длина ядра свёртки мысли (conv/gconv/ms) think_per_depth: bool = False # своё ядро свёртки мысли на каждом повторе core_mix: str = "" # ReForm: смешиватели токенов в блоках ядра (a — attention, c — FreqConv, s — shift), "" = все a value_res: bool = False # ReForm: value residual — attention ядра подмешивает V первого слоя prelude (ResFormer) depth_dense: bool = False # ReForm: вход повтора — обучаемая смесь ВСЕХ прошлых состояний мысли (DenseFormer) pointer: int = 0 # ReForm: pointer-sentinel голова (размер q/k), 0 — выкл.: копирование токена, шедшего # после похожего места в контексте; «часовой» решает, верить словарю или копии # --- экзотика (цикл S8) --- ctx_mod: bool = False # мысль = (мысль прошлого повтора + текущего)/2 × (1 + MLP(среднее e по контексту до t)) ctx_mod_learn: bool = False # вместо фиксированного /2 — обучаемый вес β (по каналам, σ(·), старт 0.5) guess_feed: bool = False # «подумай о своей догадке»: E[эмбеддинг] прогноза повтора — на вход следующему surprise: bool = False # «удивление»: −log p(x_t) от прогноза на t−1 и энтропия того прогноза — в мысль depth_rope: bool = False # «фазовая мысль»: поворот пар каналов мысли на угол r·ω на каждом повторе novelty: bool = False # «новизна»: мысль минус α ⊙ средняя мысль всего прошлого контекста halt_mix: bool = False # ReForm, инференс: смесь вероятностей всех повторов с весами p_r (ансамбль по глубине) think_drop: float = 0.0 # ReForm, обучение: вероятность пропустить обновление мысли токена на повторе lm_w: str = "lin" # веса LM-лосса по повторам: lin (∝ r) | last | flat # --- «заставить думать» (этап 2) --- think_kind: str = "c" # тип блока мышления: c — FreqConv, d — DynThinkConv («плавающая» свёртка мысли) think_block: int = 0 # отдельный «блок мышления»: N блоков FreqConv+MLP после ядра на каждом повторе # (общие для повторов; стартуют как тождество) — переработка мысли без attention think_unet: bool = False # «блок мышления» в виде маленького U-Net по времени: FreqConv → ↓2 → FreqConv → ↓2 → MLP # → ↑2 (+skip) → FreqConv → ↑2 (+skip); после ядра на каждом повторе, старт — тождество bptt_decay: float = 1.0 # обучение: градиент, уходящий по мысли в прошлый повтор, умножается на γ (мягкое усечение) bptt: int = 0 # обучение: градиент только через последние bptt повторов (ранние — без графа) mono: float = 0.0 # штраф за ухудшение: mono · relu(CE_{r+1} − CE_r) — повтор обязан не портить ответ early_noise: float = 0.0 # обучение: шум σ·(R−1−r)/(R−1) на «условие» e ранних повторов — поздние должны исправить mtp: float = 0.0 # ReForm: вес вспомогательного лосса «предскажи токен через один» (multi-token prediction) def mix(self): return (self.mixers or "a" * self.n_layer)[: self.n_layer].ljust(self.n_layer, "a") def rope_cache(T, hd, device, base=10000.0): inv = 1.0 / base ** (torch.arange(0, hd, 2, device=device).float() / hd) f = torch.outer(torch.arange(T, device=device).float(), inv) return f.cos()[None, None], f.sin()[None, None] # (1,1,T,hd/2) def apply_rope(x, cos, sin): x1, x2 = x[..., ::2], x[..., 1::2] return torch.stack([x1 * cos - x2 * sin, x1 * sin + x2 * cos], -1).flatten(-2) class Attn(nn.Module): def __init__(self, c: Cfg): super().__init__() self.h, self.qk_norm, self.p = c.heads, c.qk_norm, c.dropout self.qkv = nn.Linear(c.d, 3 * c.d, bias=False) self.proj = nn.Linear(c.d, c.d, bias=False) nn.init.zeros_(self.proj.weight) if c.value_res: self.lam = nn.Parameter(torch.tensor(0.5)) def values(self, x): B, T, D = x.shape return self.qkv(x).view(B, T, 3, self.h, D // self.h)[:, :, 2].transpose(1, 2) def forward(self, x, rope, v1=None, **_): B, T, D = x.shape q, k, v = self.qkv(x).view(B, T, 3, self.h, D // self.h).permute(2, 0, 3, 1, 4) if v1 is not None and hasattr(self, "lam"): # value residual: смесь своих V и V первого слоя v = torch.lerp(v1.to(v.dtype), v, self.lam.to(v.dtype)) if self.qk_norm: q, k = F.rms_norm(q, (q.shape[-1],)), F.rms_norm(k, (k.shape[-1],)) cos, sin = rope q, k = apply_rope(q, cos[..., :T, :], sin[..., :T, :]), apply_rope(k, cos[..., :T, :], sin[..., :T, :]) y = F.scaled_dot_product_attention(q, k, v, is_causal=True, dropout_p=self.p if self.training else 0.0) return self.proj(y.transpose(1, 2).reshape(B, T, D)) class FreqConv(nn.Module): """«Conv-attention»: y_t = Σ_j w_j ⊙ (s(tok_{t-j}) · x_{t-j}), j=0..K-1 (только прошлое), + гейт. s(tok) — обучаемый вес символа, инициализированный idf (частые символы — меньше вклад).""" def __init__(self, c: Cfg): super().__init__() self.k = c.conv_k self.conv = nn.Conv1d(c.d, c.d, c.conv_k, groups=c.d, bias=False) self.gate = nn.Linear(c.d, c.d, bias=False) self.proj = nn.Linear(c.d, c.d, bias=False) nn.init.zeros_(self.proj.weight) def forward(self, x, tok_scale=None, **_): h = x * tok_scale if tok_scale is not None else x h = F.pad(h.transpose(1, 2), (self.k - 1, 0)) # причинный паддинг слева h = self.conv(h).transpose(1, 2) return self.proj(h * F.silu(self.gate(x))) class DynThinkConv(nn.Module): """«Плавающая свёртка мысли» (идея автора): всё, что у FreqConv было фиксированным, вычисляется из самой мысли. imp = σ(MLP(x)) — «веса чисел»: какие компоненты мысли сейчас важнее (вместо idf символа) h = (x ⊙ imp) ⊙ (W·x) — взвешенная мысль, перемноженная со своей проекцией (числа влияют друг на друга) y_t = Σ_j k_t[j] ⊙ h_{t−K+1+j} — свёртка по K прошлым токенам с ядром k_t = softmax(U·x_t), своим у каждого токена и группы каналов (только прошлое — причинно) Выход — через нулевую проекцию: на старте блок не меняет мысль.""" def __init__(self, c: Cfg): super().__init__() d, self.k, self.g = c.d, c.conv_k, c.heads self.imp = nn.Sequential(nn.Linear(d, d // 2), nn.ReLU(), nn.Linear(d // 2, d)) nn.init.constant_(self.imp[2].bias, 2.0) # старт: важность ≈ 0.88 у всех чисел self.mul = nn.Linear(d, d, bias=False) self.ker = nn.Linear(d, self.g * self.k) nn.init.zeros_(self.ker.weight) # старт: равномерное окно по K токенам self.proj = nn.Linear(d, d, bias=False) nn.init.zeros_(self.proj.weight) def forward(self, x, **_): B, T, D = x.shape h = x * torch.sigmoid(self.imp(x)) * self.mul(x) win = F.pad(h, (0, 0, self.k - 1, 0)).unfold(1, self.k, 1) # (B,T,D,K): окно h[t−K+1 .. t] kt = self.ker(x).view(B, T, self.g, 1, self.k).softmax(-1) y = (win.view(B, T, self.g, D // self.g, self.k) * kt.to(win.dtype)).sum(-1).reshape(B, T, D) return self.proj(y) class Shift(nn.Module): """Token shift: lerp(x_t, x_{t-1}, μ) по каналам + линейный выход.""" def __init__(self, c: Cfg): super().__init__() self.mu = nn.Parameter(torch.full((c.d,), 0.5)) self.proj = nn.Linear(c.d, c.d, bias=False) nn.init.zeros_(self.proj.weight) def forward(self, x, **_): prev = F.pad(x, (0, 0, 1, 0))[:, :-1] return self.proj(torch.lerp(x, prev, self.mu)) class MLP(nn.Module): def __init__(self, c: Cfg): super().__init__() hidden = int(c.mlp * c.d) if c.act == "swiglu": # SwiGLU: gate + up projections, down projection. # hidden is split so params match the GELU/ReLU² version (~2/3 factor). hidden = int(hidden * 2 / 3) self.fc = nn.Linear(c.d, 2 * hidden, bias=False) # [gate | up] self.out = nn.Linear(hidden, c.d, bias=False) else: self.fc = nn.Linear(c.d, hidden, bias=False) self.out = nn.Linear(hidden, c.d, bias=False) nn.init.zeros_(self.out.weight) self.act = c.act self.hidden = hidden def forward(self, x): h = self.fc(x) if self.act == "swiglu": gate, up = h.chunk(2, dim=-1) h = F.silu(gate) * up elif self.act == "relu2": h = F.relu(h).square() else: h = F.gelu(h) return self.out(h) class Block(nn.Module): def __init__(self, c: Cfg, kind): super().__init__() self.n1, self.n2 = nn.RMSNorm(c.d), nn.RMSNorm(c.d) self.mix = {"a": Attn, "c": FreqConv, "s": Shift, "d": DynThinkConv}[kind](c) self.mlp = MLP(c) self.drop = nn.Dropout(c.dropout) def forward(self, x, **kw): x = x + self.drop(self.mix(self.n1(x), **kw)) return x + self.drop(self.mlp(self.n2(x))) class NGramTables(nn.Module): """Счётчики n-грамм по train-тексту: для порядка n — таблица (V^(n-1), V) int32.""" def __init__(self, train_ids, V, max_order): super().__init__() self.V, self.orders = V, list(range(2, max_order + 1)) for n in self.orders: ctxn = n - 1 idx = torch.zeros(len(train_ids) - ctxn, dtype=torch.long, device=train_ids.device) for j in range(ctxn): idx = idx * V + train_ids[j: len(train_ids) - ctxn + j] nxt = train_ids[ctxn:] t = torch.zeros(V ** ctxn * V, dtype=torch.int32, device=train_ids.device) t.index_add_(0, idx * V + nxt, torch.ones_like(nxt, dtype=torch.int32)) self.register_buffer(f"t{n}", t.view(V ** ctxn, V), persistent=False) self.register_buffer("uni", torch.bincount(train_ids, minlength=V).float(), persistent=False) def logprobs(self, idx, targets=None, k=0.05): """-> (B,T,orders,V) log P(next | контекст порядка n). Позиции без полного контекста -> униграмма. targets != None (обучение) -> leave-one-out: вычитаем сам пример из счётчиков.""" B, T = idx.shape out = [] uni = (self.uni + k) / (self.uni.sum() + k * self.V) for n in self.orders: ctxn = n - 1 key = torch.zeros(B, T, dtype=torch.long, device=idx.device) for j in range(ctxn): # контекст: idx[t-ctxn+1 .. t] key = key * self.V + F.pad(idx, (ctxn - 1 - j, 0))[:, : T] cnt = getattr(self, f"t{n}")[key].float() # (B,T,V) if targets is not None: cnt = cnt - F.one_hot(targets, self.V).float() cnt = cnt.clamp_min(0) p = (cnt + k * uni * self.V) / (cnt.sum(-1, keepdim=True) + k * self.V) valid = (torch.arange(T, device=idx.device) >= ctxn - 1)[None, :, None] out.append(torch.where(valid, p, uni).log()) return torch.stack(out, 2) class HFGPT2(nn.Module): """Эталонный «классический» Transformer: GPT-2 из 🤗 transformers, обучаемый с нуля (LayerNorm, обучаемые позиции, GELU, attention через SDPA). Интерфейс как у GPT.""" def __init__(self, c: Cfg): super().__init__() from transformers import GPT2Config, GPT2LMHeadModel conf = GPT2Config(vocab_size=c.vocab, n_positions=c.ctx, n_embd=c.d, n_layer=c.n_layer, n_head=c.heads, n_inner=int(c.mlp * c.d), resid_pdrop=c.dropout, embd_pdrop=c.dropout, attn_pdrop=c.dropout, use_cache=False) conf._attn_implementation = "sdpa" self.m = GPT2LMHeadModel(conf) self.c = c def forward(self, idx, targets=None): logits = self.m(input_ids=idx).logits.float() if targets is None: return logits return logits, F.cross_entropy(logits.view(-1, logits.size(-1)), targets.view(-1)) def context_ngram_logprobs(idx, V, max_len, k=0.5): """Индукция без обучения: для позиции t ищем прошлые j (B,T,max_len,V) log-вероятности (сглаженные к равномерному распределению).""" B, T = idx.shape nxt = F.one_hot(F.pad(idx[:, 1:], (0, 1)), V).to(torch.bfloat16) # nxt[j] = idx[j+1] past = torch.tril(torch.ones(T, T, dtype=torch.bool, device=idx.device), -1) # j < t eq = past[None].expand(B, T, T) out = [] for m in range(max_len): sh_t = F.pad(idx, (m, 0), value=-1)[:, :T] # idx[t-m] eq = eq & (sh_t[:, :, None] == sh_t[:, None, :]) # суффикс длины m+1 совпал cnt = torch.bmm(eq.to(torch.bfloat16), nxt).float() # (B,T,V) out.append(((cnt + k / V) / (cnt.sum(-1, keepdim=True) + k)).log()) return torch.stack(out, 2) class GPT(nn.Module): def __init__(self, c: Cfg, train_ids=None): super().__init__() self.c = c self.emb = nn.Embedding(c.vocab, c.d) self.blocks = nn.ModuleList([Block(c, k) for k in c.mix()]) self.norm = nn.RMSNorm(c.d) self.head = nn.Linear(c.d, c.vocab, bias=False) if c.emb_std: nn.init.normal_(self.emb.weight, std=c.emb_std) if c.tie: self.head.weight = self.emb.weight hd = c.d // c.heads cos, sin = rope_cache(c.ctx, hd, "cpu") self.register_buffer("cos", cos, persistent=False) self.register_buffer("sin", sin, persistent=False) need_freq = "c" in c.mix() if need_freq or c.ngram_prior or c.ctx_count: assert train_ids is not None, "статистическим слоям нужен train-текст" if need_freq: # idf-инициализация веса символа: log(N / count), нормированная к среднему 1 cnt = torch.bincount(train_ids.cpu(), minlength=c.vocab).float() + 1 idf = torch.log(cnt.sum() / cnt) self.tok_scale = nn.Parameter(idf / idf.mean()) if c.ngram_embed: self.ng_emb = nn.ModuleList([nn.Embedding(c.ngram_buckets, c.d) for _ in range(2, c.ngram_embed + 1)]) for e in self.ng_emb: nn.init.zeros_(e.weight) if c.ctx_count: self.count_emb = nn.Embedding(8, c.d) nn.init.zeros_(self.count_emb.weight) if c.ngram_prior: self.ngram = NGramTables(train_ids, c.vocab, c.ngram_prior) self.mix_w = nn.Linear(c.d, len(self.ngram.orders)) nn.init.zeros_(self.mix_w.weight) nn.init.constant_(self.mix_w.bias, -2.0) if c.ctx_ngram: self.ctx_w = nn.Linear(c.d, c.ctx_ngram) nn.init.zeros_(self.ctx_w.weight) nn.init.constant_(self.ctx_w.bias, -2.0) def forward(self, idx, targets=None): B, T = idx.shape c = self.c x = self.emb(idx) if c.ngram_embed: # хэш контекста из n-1 предыдущих символов + текущего key = idx.clone() for n, e in zip(range(2, c.ngram_embed + 1), self.ng_emb): key = key * 1000003 + F.pad(idx, (n - 1, 0))[:, :T] x = x + e(key % c.ngram_buckets) if c.ctx_count: # сколько раз этот символ уже был в контексте: 0,1,2,3,4-7,8-15,16-31,32+ oh = F.one_hot(idx, c.vocab) seen = (oh.cumsum(1) - oh).gather(2, idx[..., None])[..., 0] bucket = torch.where(seen < 4, seen, (torch.log2(seen.float().clamp_min(1)).floor() + 2).long()).clamp_max(7) x = x + self.count_emb(bucket) x = F.dropout(x, c.dropout, self.training) ts = self.tok_scale[idx][..., None].to(x.dtype) if hasattr(self, "tok_scale") else None rope = (self.cos, self.sin) for b in self.blocks: x = b(x, rope=rope, tok_scale=ts) h = self.norm(x) logits = self.head(h).float() if c.ngram_prior: # нейросеть + смесь n-граммных распределений с весами по позиции lp = self.ngram.logprobs(idx, targets) # (B,T,O,V) w = F.softplus(self.mix_w(h).float())[..., None] # (B,T,O,1) logits = logits + (w * lp).sum(2) if c.ctx_ngram: # статистическая «индукционная голова» по текущему контексту lp = context_ngram_logprobs(idx, c.vocab, c.ctx_ngram) w = F.softplus(self.ctx_w(h).float())[..., None] logits = logits + (w * lp).sum(2) if targets is None: return logits return logits, F.cross_entropy(logits.view(-1, c.vocab), targets.view(-1)) class _GradScale(torch.autograd.Function): """Вперёд — тождество, назад — градиент × γ.""" @staticmethod def forward(ctx, x, g): ctx.g = g return x.view_as(x) @staticmethod def backward(ctx, gy): return gy * ctx.g, None def causal_dwconv(x, kern, dil=1): """x (B,T,D), kern (D,K): y_t = Σ_j kern[:, j] ⊙ x_{t − j·dil} — только прошлое.""" K = kern.shape[1] w = kern.flip(-1)[:, None, :].to(x.dtype) h = F.pad(x.transpose(1, 2), ((K - 1) * dil, 0)) return F.conv1d(h, w, groups=x.shape[-1], dilation=dil).transpose(1, 2).to(x.dtype) class ThoughtUNet(nn.Module): """Мысль на нескольких масштабах времени. Сжатие ×2 причинное (как в Hourglass Transformer): последовательность сдвигается вправо на 1, и «крупный» токен j склеивает x[2j−1], x[2j]; при развёртке он достаётся токенам 2j и 2j+1 — оба не раньше всего, что в нём есть. Два уровня: ×2 и ×4 (FreqConv на крупных токенах видит в 2 и 4 раза дальше).""" def __init__(self, c: Cfg): super().__init__() d = c.d self.c0, self.c1, self.c2 = FreqConv(c), FreqConv(c), FreqConv(c) # ↓-уровень 0, ↓-уровень 1, ↑-уровень 1 self.n0, self.n1, self.n2, self.nm = nn.RMSNorm(d), nn.RMSNorm(d), nn.RMSNorm(d), nn.RMSNorm(d) self.down1, self.down2 = nn.Linear(2 * d, d, bias=False), nn.Linear(2 * d, d, bias=False) self.mid = nn.Sequential(nn.Linear(d, 2 * d, bias=False), nn.ReLU(), nn.Linear(2 * d, d, bias=False)) self.up2, self.up1 = nn.Linear(d, d, bias=False), nn.Linear(d, d, bias=False) self.out = nn.Linear(d, d, bias=False) nn.init.zeros_(self.out.weight) # старт: блок = тождество @staticmethod def down(x, lin): B, T, D = x.shape x = F.pad(x, (0, 0, 1, 0))[:, :T] # сдвиг: пара = (t−1, t) return lin(x.reshape(B, T // 2, 2 * D)) @staticmethod def up(z, lin): return lin(z).repeat_interleave(2, dim=1) def forward(self, x): B, T, D = x.shape Tp = -(-T // 4) * 4 h = F.pad(x, (0, 0, 0, Tp - T)) # хвост справа — только «будущее», срежем h0 = h + self.c0(self.n0(h)) z1 = self.down(h0, self.down1) z1 = z1 + self.c1(self.n1(z1)) z2 = self.down(z1, self.down2) z2 = z2 + self.mid(self.nm(z2)) u1 = z1 + self.up(z2, self.up2) u1 = u1 + self.c2(self.n2(u1)) u0 = h0 + self.up(u1, self.up1) return x + self.out(u0[:, :T]) class ThoughtConv(nn.Module): """Свёртка мысли по времени: мысль токена — смесь мыслей нескольких предыдущих токенов на той же глубине. conv — y = Σ_j w_j ⊙ s_{t−j}, j < K (сдвиг мысли — частный случай K=2) gconv — s + σ(W·norm(s)) ⊙ (conv(s) − s): токен сам решает, насколько слушать соседей ms — сумма свёрток с растяжением 1, 2, 4, 8: соседи на разных расстояниях (до ~8K токенов) ema — экспоненциальное среднее мысли по всему прошлому, своё затухание у каждого канала Старт — ровно сдвиг мысли (0.75·s_t + 0.25·s_{t−1}), чтобы не терять найденное.""" def __init__(self, c: Cfg): super().__init__() d, K, self.kind = c.d, c.think_k, c.think_conv self.nk = c.r_max if c.think_per_depth else 1 if self.kind == "ema": self.decay = nn.Parameter(torch.linspace(0.0, 4.0, d).repeat(self.nk, 1)) # логит затухания self.mu = nn.Parameter(torch.full((self.nk, d), 0.25)) return self.dil = [1, 2, 4, 8] if self.kind == "ms" else [1] w = torch.zeros(self.nk, len(self.dil), d, K) w[:, 0, :, 0], w[:, 0, :, 1] = 0.75, 0.25 self.w = nn.Parameter(w) if self.kind == "gconv": self.gate = nn.Linear(d, d) nn.init.zeros_(self.gate.weight) nn.init.constant_(self.gate.bias, 2.0) # старт: почти полностью conv(s) def forward(self, s, r, norm): i = min(r, self.nk - 1) if self.kind == "ema": T = s.shape[1] a = torch.sigmoid(self.decay[i].float())[:, None] kern = (1 - a) * a ** torch.arange(T, device=s.device, dtype=torch.float32)[None] return torch.lerp(s, causal_dwconv(s, kern), self.mu[i].to(s.dtype)) y = sum(causal_dwconv(s, self.w[i, j], dl) for j, dl in enumerate(self.dil)) if self.kind == "gconv": return s + torch.sigmoid(self.gate(norm(s))) * (y - s) return y class ReForm(nn.Module): """Рекуррентный по глубине Transformer: prelude -> core × r (общие веса) -> ответ на каждом повторе. e = norm(prelude(emb(idx))) — «условие задачи», считается один раз s_0 = s0 (+ шум на обучении) — латентный вектор: рабочее состояние «мысли» токена s_r = core(W·[norm(s_{r-1}); e] + depth[r]) — input injection: каждый повтор снова видит условие y_r = head(norm(s_r)) (+ стат. индукционная голова) — ответ после r повторов λ_r = σ(halt([norm(s_r); log‖Δs‖/‖s‖; H(y_r)])) — голова остановки: «хватит повторять?» «Сколько раз повторить» — распределение PonderNet: p_r = λ_r Π_{j r_max — экстраполяция: можно «подумать» дольше, чем учили. """ def __init__(self, c: Cfg, train_ids=None): super().__init__() self.c = c d = c.d self.emb = nn.Embedding(c.vocab, d) self.prelude = nn.ModuleList([Block(c, "a") for _ in range(c.prelude)]) self.core = nn.ModuleList([Block(c, k) for k in (c.core_mix or "a" * c.core)[: c.core].ljust(c.core, "a")]) self.n_e, self.n_s, self.norm = nn.RMSNorm(d), nn.RMSNorm(d), nn.RMSNorm(d) self.s0 = nn.Parameter(torch.randn(d) * 0.02) # латентный вектор (начальное состояние) m = c.think_slots self.inject = nn.Linear((3 if m else 2) * d, d, bias=False) # [s; e; прочитанное из памяти] -> ядро with torch.no_grad(): w = [torch.eye(d) * 0.5, torch.eye(d) * 0.5] + ([torch.zeros(d, d)] if m else []) self.inject.weight.copy_(torch.cat(w, 1)) if m: # слоты — активации (B,T,m,d), а не веса: веса только у начальных слотов и адресации self.slots0 = nn.Parameter(torch.randn(m, d) * 0.5) self.n_m = nn.RMSNorm(d) self.addr_r, self.addr_w = nn.Linear(d, m), nn.Linear(d, m) for a in (self.addr_r, self.addr_w): nn.init.zeros_(a.weight) nn.init.zeros_(a.bias) if c.think_shift: self.mu = nn.Parameter(torch.full((d,), 0.25)) if c.think_conv: self.tconv = ThoughtConv(c) if c.think_block: self.tblocks = nn.ModuleList([Block(c, c.think_kind) for _ in range(c.think_block)]) if c.think_unet: self.tunet = ThoughtUNet(c) if c.ctx_mod: self.cm = nn.Sequential(nn.Linear(d, d // 2), nn.ReLU(), nn.Linear(d // 2, d)) nn.init.zeros_(self.cm[2].weight) nn.init.zeros_(self.cm[2].bias) if c.ctx_mod_learn: # логит веса текущей мысли: σ(0) = 0.5 — старт ровно как (прошлая + текущая)/2 self.cm_beta = nn.Parameter(torch.zeros(d)) if c.guess_feed: self.gf = nn.Linear(d, d, bias=False) nn.init.zeros_(self.gf.weight) if c.surprise: self.sp = nn.Linear(2, d) nn.init.zeros_(self.sp.weight) nn.init.zeros_(self.sp.bias) if c.depth_rope: # частоты поворота по глубине, от медленных к быстрым self.dr_w = nn.Parameter(torch.linspace(0.05, 1.5, d // 2)) if c.novelty: self.nov = nn.Parameter(torch.zeros(d)) if c.pointer: self.ptr_q, self.ptr_k = nn.Linear(d, c.pointer, bias=False), nn.Linear(d, c.pointer, bias=False) self.ptr_s = nn.Linear(d, 1) nn.init.zeros_(self.ptr_s.weight) nn.init.constant_(self.ptr_s.bias, math.log(c.ctx) + 2.0) # старт: почти всё — словарю if c.depth_dense: # dense_a[r, j] — вес состояния после j-го повтора во входе повтора r; старт — только последнее self.dense_a = nn.Parameter(torch.eye(c.r_max, c.r_max + 1)) if c.ngram_prior: # статистический prior по счётчикам train (как у GPT), веса смеси — по мысли self.ngram = NGramTables(train_ids, c.vocab, c.ngram_prior) self.mix_w = nn.Linear(d, len(self.ngram.orders)) nn.init.zeros_(self.mix_w.weight) nn.init.constant_(self.mix_w.bias, -2.0) if c.mtp: # голова «через один»: своя проекция мысли, общий с головой словарь self.mtp_proj = nn.Linear(d, d, bias=False) nn.init.eye_(self.mtp_proj.weight) self.depth = nn.Parameter(torch.zeros(c.r_max, d)) # «номер повтора» if c.depth_norm: # (повтор, блок ядра, n1/n2, d) — множители к весам RMSNorm общих блоков self.depth_g = nn.Parameter(torch.ones(c.r_max, c.core, 2, d)) if c.latent_gate: self.gate = nn.Linear(d, d) nn.init.zeros_(self.gate.weight) nn.init.constant_(self.gate.bias, 1.0) # старт: z ≈ 0.73, в основном новое self.head = nn.Linear(d, c.vocab, bias=False) if c.emb_std: nn.init.normal_(self.emb.weight, std=c.emb_std) if c.tie: self.head.weight = self.emb.weight self.halt = nn.Linear(d + 2, 1) nn.init.zeros_(self.halt.weight) nn.init.zeros_(self.halt.bias) # старт — равномерное p_r: λ_r = 1/(r_max − r) self.halt_bias = nn.Parameter(torch.tensor([-math.log(c.r_max - r - 1) if r < c.r_max - 1 else 0.0 for r in range(c.r_max)])) if c.ctx_ngram: self.ctx_w = nn.Linear(d, c.ctx_ngram) nn.init.zeros_(self.ctx_w.weight) nn.init.constant_(self.ctx_w.bias, -2.0) cos, sin = rope_cache(c.ctx, d // c.heads, "cpu") self.register_buffer("cos", cos, persistent=False) self.register_buffer("sin", sin, persistent=False) self.stats = {} def forward(self, idx, targets=None, n_iter=None, last_exit=False, return_all=False, bptt=None): B, T = idx.shape c = self.c R = n_iter or c.r_max rope = (self.cos, self.sin) x = F.dropout(self.emb(idx), c.dropout, self.training) v1 = self.prelude[0].mix.values(self.prelude[0].n1(x)) if c.value_res and c.prelude else None for b in self.prelude: x = b(x, rope=rope) e = self.n_e(x) hist = [] s = self.s0.to(e.dtype).expand(B, T, -1) if self.training and c.latent_noise: s = s + c.latent_noise * torch.randn_like(s) if c.think_slots: M = self.slots0.to(e.dtype).expand(B, T, -1, -1) prior = context_ngram_logprobs(idx, c.vocab, c.ctx_ngram) if c.ctx_ngram else None nlp = self.ngram.logprobs(idx, targets) if c.ngram_prior else None if c.pointer: # ключи — по «условию» e (один раз), значения — следующий токен после позиции j pk = self.ptr_k(e) nxt = F.one_hot(F.pad(idx[:, 1:], (0, 1)), c.vocab).to(torch.bfloat16) pmask = torch.ones(T, T, dtype=torch.bool, device=idx.device).tril(-1) # j < t: idx[j+1] уже известен logits_all, ps = [], [] rem = torch.ones(B, T, device=idx.device) if c.ctx_mod or c.novelty: # причинное среднее по времени матрицей (cumsum ломает Inductor) avg = torch.ones(T, T, device=idx.device).tril() avg = (avg / avg.sum(1, keepdim=True)).to(e.dtype) if c.ctx_mod: # «прогон всего контекста через MLP» — причинно: среднее e от начала до t cm_g = 1 + self.cm(avg @ e) s_prev, extra = None, None for r in range(R): kb = bptt if bptt is not None else c.bptt # bptt из обучения (инкрементальная схема) важнее конфига ng = self.training and kb and r < R - kb # ранний повтор: считаем без графа with torch.no_grad() if ng else contextlib.nullcontext(): di = min(r, c.r_max - 1) if c.depth_dense: hist.append(s) if 0 < r < c.r_max: s = sum(self.dense_a[r, j].to(s.dtype) * hist[j] for j in range(r + 1)) if c.think_shift: # мысль продолжает мысль соседа слева (только прошлое — причинно) s = torch.lerp(s, F.pad(s, (0, 0, 1, 0))[:, :-1], self.mu.to(s.dtype)) if c.think_conv: # свёртка мысли по нескольким прошлым токенам s = self.tconv(s, r, self.n_s) if c.novelty: # оставляем то, что в мысли нового относительно всей сцены s = s - self.nov.to(s.dtype) * (avg.to(s.dtype) @ s) if c.ctx_mod and s_prev is not None: if c.ctx_mod_learn: s = torch.lerp(s_prev, s, torch.sigmoid(self.cm_beta).to(s.dtype)) * cm_g else: s = 0.5 * (s + s_prev) * cm_g if c.depth_rope: ang = (r + 1) * self.dr_w.float() s = apply_rope(s, ang.cos().to(s.dtype), ang.sin().to(s.dtype)) e_r = e if self.training and c.early_noise and R > 1: # ранние повторы видят «зашумлённое условие» e_r = e + (c.early_noise * (R - 1 - r) / (R - 1)) * torch.randn_like(e) inp = [self.n_s(s), e_r] if c.think_slots: # чтение: адрес = выученный по мысли + сходство мысли со слотом q = self.n_s(s) nM = self.n_m(M) sc = self.addr_r(q) + (nM @ q[..., None])[..., 0] / math.sqrt(c.d) inp.append(self.n_m((sc.softmax(-1)[..., None, :] @ M)[..., 0, :])) h_new = self.inject(torch.cat(inp, -1)) + self.depth[di].to(e.dtype) if extra is not None: # догадка / удивление прошлого повтора h_new = h_new + extra.to(h_new.dtype) for j, b in enumerate(self.core): if c.depth_norm: g = self.depth_g[di, j].to(h_new.dtype) h_new = h_new + b.drop(b.mix(b.n1(h_new) * g[0], rope=rope, v1=v1)) h_new = h_new + b.drop(b.mlp(b.n2(h_new) * g[1])) else: h_new = b(h_new, rope=rope, v1=v1) if c.think_block: # блок мышления: мысль после ядра дорабатывается FreqConv+MLP for tb in self.tblocks: h_new = tb(h_new) if c.think_unet: # блок мышления U-Net: мысль на масштабах ×1, ×2, ×4 h_new = self.tunet(h_new) if c.think_slots: # запись: мысль плавно сдвигает выбранный слот к себе, остальные хранят старое ww = self.addr_w(self.n_s(h_new)).softmax(-1)[..., None] M = M + ww * (h_new[..., None, :] - M) if c.latent_gate: h_new = s + torch.sigmoid(self.gate(self.n_s(h_new))) * (h_new - s) if self.training and c.think_drop and r > 0: # у части токенов мысль на этом повторе не меняется keep = (torch.rand(B, T, 1, device=idx.device) >= c.think_drop).to(h_new.dtype) h_new = s + keep * (h_new - s) h = self.norm(h_new) lg = self.head(h).float() if prior is not None: lg = lg + (F.softplus(self.ctx_w(h).float())[..., None] * prior).sum(2) if nlp is not None: lg = lg + (F.softplus(self.mix_w(h).float())[..., None] * nlp).sum(2) if c.pointer: # p = a_sent·softmax(lg) + Σ_j a_j·onehot(idx[j+1]); возвращаем log p sc = (self.ptr_q(h) @ pk.transpose(1, 2)).float() / math.sqrt(c.pointer) sc = sc.masked_fill(~pmask, float("-inf")) a = torch.cat([sc, self.ptr_s(h).float()], -1).softmax(-1) # (B,T,T+1) ptr = torch.bmm(a[..., :T].to(torch.bfloat16), nxt).float() lg = torch.log(a[..., T:] * lg.softmax(-1) + ptr + 1e-9) if r < R - 1: # признаки головы остановки (без градиента в LM) with torch.no_grad(): dn, sn = (h_new - s).float().norm(dim=-1), h_new.float().norm(dim=-1) conv = torch.log(dn / (sn + 1e-6) + 1e-6) lp = F.log_softmax(lg, -1) ent = -(lp.exp() * lp).sum(-1) feat = torch.cat([h.detach().float(), conv[..., None], ent[..., None]], -1) lam = torch.sigmoid(self.halt(feat)[..., 0].float() + self.halt_bias[di]) else: lam = torch.ones_like(rem) ps.append(rem * lam) rem = rem * (1 - lam) logits_all.append(lg) if r < R - 1 and (c.guess_feed or c.surprise): extra = 0 if c.guess_feed: # ожидаемый эмбеддинг собственного прогноза extra = extra + self.gf(lg.softmax(-1).to(self.emb.weight.dtype) @ self.emb.weight) if c.surprise: # насколько неожиданным был пришедший токен x_t для прогноза на t−1 with torch.no_grad(): lpp = F.log_softmax(lg, -1) sur = -lpp[:, :-1].gather(-1, idx[:, 1:, None]) ent = -(lpp.exp() * lpp).sum(-1, keepdim=True)[:, :-1] f = F.pad(torch.cat([sur, ent], -1), (0, 0, 1, 0)) / 5.0 extra = extra + self.sp(f) s_prev, s = s, h_new if self.training and c.bptt_decay < 1.0: # мягкое усечение: в прошлые повторы — ослабленный градиент s = _GradScale.apply(s, c.bptt_decay) if last_exit and r < R - 1 and (1 - rem[:, -1]).min() >= 0.5: # последний токен «решил» self.stats = dict(iters=r + 1) return lg L, P = torch.stack(logits_all), torch.stack(ps) # (R,B,T,V), (R,B,T) if return_all: return L, P if targets is None and c.halt_mix: # ансамбль по глубине: log Σ_r p_r·softmax(y_r) self.stats = dict(iters=R) return torch.logsumexp(F.log_softmax(L, -1) + P.clamp_min(1e-9).log()[..., None], 0) if targets is None: # адаптивная глубина: медиана распределения остановки, у каждого токена своя r_star = ((P.cumsum(0) < 0.5).sum(0)).clamp_max(R - 1) # (B,T) self.stats = dict(iters=(r_star + 1).float().mean().item(), iters_last=r_star[:, -1].float().mean().item() + 1) return L.gather(0, r_star[None, ..., None].expand(1, B, T, c.vocab))[0] ce = F.cross_entropy(L.view(-1, c.vocab), targets.repeat(R, 1).view(-1), reduction="none").view(R, B, T) w = torch.arange(1, R + 1, device=idx.device, dtype=torch.float32) if c.lm_w == "last": w = (w == R).float() elif c.lm_w == "flat": w = torch.ones_like(w) lm = (ce.mean((1, 2)) * w).sum() / w.sum() if c.mono and R > 1: # каждый следующий повтор — не хуже предыдущего (предыдущий не тянем вверх) lm = lm + c.mono * F.relu(ce[1:] - ce[:-1].detach()).mean() depth_cost = torch.arange(1, R + 1, device=idx.device, dtype=torch.float32)[:, None, None] halt_loss = (P * (ce.detach() + c.ponder_beta * depth_cost)).sum(0).mean() if c.mtp: # из последней мысли токена t предсказываем токен t+2 lg2 = self.head(self.norm(self.mtp_proj(h_new[:, :-1]))).float() lm = lm + c.mtp * F.cross_entropy(lg2.reshape(-1, c.vocab), targets[:, 1:].reshape(-1)) return L[-1], lm + halt_loss