File size: 3,291 Bytes
89c4be1 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 | """
brain/model/initialization.py
Weight initialization, applied once after the full model is constructed.
Uses the GPT-2 / nanoGPT scheme: all Linear/Embedding weights ~ N(0, 0.02),
EXCEPT the two projections that write directly back into the residual
stream (attention's o_proj, SwiGLU's down_proj), which get an extra
1/sqrt(2 * num_layers) scale-down. Without that scale-down, variance
in the residual stream compounds additively over depth (each of the
2*num_layers sublayers adds roughly full-scale noise into the same
stream), and a 12-layer model is deep enough for this to visibly
destabilize early training. This is a well-established fix (GPT-2,
nanoGPT), not a Brain-specific invention.
The Brain Trail prototype used plain default PyTorch initialization
(Linear's kaiming-uniform default) with no depth-aware scaling at all --
harmless at 2 layers, exactly the kind of thing that stops being harmless
at 12.
"""
from __future__ import annotations
import math
import torch.nn as nn
from brain.model.transformer.attention import CausalSelfAttention
from brain.model.transformer.mlp import SwiGLU
def init_weights(model: nn.Module, num_layers: int, base_std: float = 0.02) -> None:
residual_std = base_std / math.sqrt(2 * num_layers)
# Tag the two "writes back into the residual stream" projections so the
# generic pass below can single them out, without hardcoding parameter
# NAMES (which would silently break if a module gets renamed).
residual_write_modules: set[int] = set()
for module in model.modules():
if isinstance(module, CausalSelfAttention):
residual_write_modules.add(id(module.o_proj))
elif isinstance(module, SwiGLU):
residual_write_modules.add(id(module.down_proj))
for module in model.modules():
if isinstance(module, nn.Linear):
std = residual_std if id(module) in residual_write_modules else base_std
nn.init.normal_(module.weight, mean=0.0, std=std)
if module.bias is not None:
nn.init.zeros_(module.bias)
elif isinstance(module, nn.Embedding):
nn.init.normal_(module.weight, mean=0.0, std=base_std)
if module.padding_idx is not None:
with __import__("torch").no_grad():
module.weight[module.padding_idx].fill_(0.0)
# ---------------------------------------------------------------------------
if __name__ == "__main__":
import torch
from brain.core.config import BrainConfig
from brain.model.transformer.block import TransformerBlock
cfg = BrainConfig(hidden_size=32, num_layers=4, num_heads=4, num_kv_heads=2, intermediate_size=64)
blocks = nn.ModuleList([TransformerBlock(cfg) for _ in range(cfg.num_layers)])
init_weights(blocks, num_layers=cfg.num_layers)
o_proj_std = blocks[0].attention.o_proj.weight.std().item()
q_proj_std = blocks[0].attention.q_proj.weight.std().item()
expected_residual_std = 0.02 / math.sqrt(2 * cfg.num_layers)
print(f"q_proj (non-residual-write) weight std: {q_proj_std:.4f} (expected ~0.02)")
print(f"o_proj (residual-write) weight std: {o_proj_std:.4f} (expected ~{expected_residual_std:.4f})")
print(f"o_proj std correctly scaled down: {o_proj_std < q_proj_std}")
|