Download reform_model.py from RedCatTeam/ReFORM-C10: direct link, hf CLI and curl.
- Browser
- Download file 48 kB
-
https://huggingface.co/RedCatTeam/ReFORM-C10/resolve/main/reform_model.py
- Command line
-
hf download hf://RedCatTeam/ReFORM-C10/reform_model.py
-
curl -L -o reform_model.py https://huggingface.co/RedCatTeam/ReFORM-C10/resolve/main/reform_model.py
48 kB
| """Маленький 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 | |
| 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<t с тем же суффиксом длины m (1..max_len) | |
| и считаем, какие символы шли сразу после них (idx[j+1], j+1<=t — только прошлое). | |
| -> (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): | |
| """Вперёд — тождество, назад — градиент × γ.""" | |
| def forward(ctx, x, g): | |
| ctx.g = g | |
| return x.view_as(x) | |
| 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) # старт: блок = тождество | |
| 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)) | |
| 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}(1 − λ_j), остаток — на последний. | |
| Голова остановки отделена от языковой модели (stop-gradient): LM учится отвечать на любой глубине | |
| (Σ w_r·CE_r, w_r ∝ r — глубже весомее), а голова учится по Σ p_r·CE_r.detach() + β·E[r], то есть | |
| останавливаться там, где следующий повтор уже не окупает свою цену β. Так она не может «сломать» | |
| модель, схлопнув глубину в 1 в начале обучения (типичная беда PonderNet/ACT). | |
| Инференс: для каждого токена берём первый r, где Σ_{j≤r} p_j ≥ 0.5; при генерации цикл | |
| обрывается, как только остановился последний токен — реальная экономия вычислений. | |
| n_iter > 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 | |