Text Generation
English
ReFORM-C10 / reform_model.py
Kotodobr's picture
Upload 3 files
7051f0d verified
Raw History Blame Contribute Delete
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
@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<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):
"""Вперёд — тождество, назад — градиент × γ."""
@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}(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