File size: 8,553 Bytes
d02c2a6 | 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 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 | from typing import List
import torch
class Automagic2(torch.optim.Optimizer):
"""
Automagic v2.
A single scalar learning rate is kept per parameter (e.g. one lr for the
full weight matrix of a Linear layer rather than one per element). The lr
is nudged up when the per-element update direction stays consistent with
the previous step and nudged down when it flips, clamped to [min_lr, max_lr].
The optimizer step is fused into the backward pass via
``register_post_accumulate_grad_hook``: each parameter is updated and its
grad freed as soon as autograd finishes accumulating into it. ``.step()``
therefore does no real work and peak VRAM stays low.
Second-moment EMA state is stored in ``p.dtype`` (math runs in fp32 when
the state is lower precision). Stochastic rounding is applied only when
writing back to a bf16 parameter.
"""
def __init__(
self,
params,
lr: float = 1e-6,
min_lr: float = 1e-7,
max_lr: float = 1e-3,
lr_bump: float = 1e-6,
beta2: float = 0.999,
eps: float = 1e-30,
clip_threshold: float = 1.0,
weight_decay: float = 0.0,
agreement_threshold: float = 0.6,
):
if lr > 1e-3:
print(f"Warning! Start lr {lr} is very high; forcing to 1e-6.")
lr = 1e-6
defaults = dict(
lr=lr,
min_lr=min_lr,
max_lr=max_lr,
lr_bump=lr_bump,
beta2=beta2,
eps=eps,
clip_threshold=clip_threshold,
weight_decay=weight_decay,
agreement_threshold=agreement_threshold,
)
super().__init__(params, defaults)
self._hook_handles = []
for group in self.param_groups:
for p in group["params"]:
if p.requires_grad:
handle = p.register_post_accumulate_grad_hook(
self._make_backward_hook(group)
)
self._hook_handles.append(handle)
total = sum(p.numel() for g in self.param_groups for p in g["params"])
print(f"Total training paramiters: {total:,}")
# ------------------------------------------------------------------ utils
@staticmethod
def _rms(t: torch.Tensor) -> torch.Tensor:
return t.norm(2) / (t.numel() ** 0.5)
@staticmethod
def _approx_sq_grad(row: torch.Tensor, col: torch.Tensor) -> torch.Tensor:
r = (row / row.mean(dim=-1, keepdim=True)).rsqrt_().unsqueeze(-1)
c = col.unsqueeze(-2).rsqrt()
return torch.mul(r, c)
def _init_state(self, p: torch.Tensor, group: dict) -> None:
state = self.state[p]
state["step"] = 0
state["lr"] = torch.full(
(), float(group["lr"]), dtype=torch.float32, device=p.device
)
state["last_polarity"] = torch.zeros(p.shape, dtype=torch.bool, device=p.device)
if p.dim() >= 2:
state["exp_avg_sq_row"] = torch.zeros(
p.shape[:-1], dtype=p.dtype, device=p.device
)
state["exp_avg_sq_col"] = torch.zeros(
p.shape[:-2] + p.shape[-1:], dtype=p.dtype, device=p.device
)
else:
state["exp_avg_sq"] = torch.zeros(p.shape, dtype=p.dtype, device=p.device)
def _make_backward_hook(self, group):
def _hook(p: torch.Tensor):
self._update_param(p, group)
return _hook
# -------------------------------------------------------------- per-param
@torch.no_grad()
def _update_param(self, p: torch.Tensor, group: dict) -> None:
if p.grad is None:
return
state = self.state[p]
if len(state) == 0:
self._init_state(p, group)
grad = p.grad
if grad.is_sparse:
raise RuntimeError("Automagic2 does not support sparse gradients.")
if grad.dtype != torch.float32:
grad = grad.to(torch.float32)
beta2 = group["beta2"]
eps = group["eps"]
sq = (grad * grad).add_(eps)
if p.dim() >= 2:
row_state = state["exp_avg_sq_row"]
col_state = state["exp_avg_sq_col"]
if row_state.dtype == torch.float32:
row, col = row_state, col_state
row.mul_(beta2).add_(sq.mean(dim=-1), alpha=1.0 - beta2)
col.mul_(beta2).add_(sq.mean(dim=-2), alpha=1.0 - beta2)
else:
row = row_state.to(torch.float32)
col = col_state.to(torch.float32)
row.mul_(beta2).add_(sq.mean(dim=-1), alpha=1.0 - beta2)
col.mul_(beta2).add_(sq.mean(dim=-2), alpha=1.0 - beta2)
row_state.copy_(row.to(row_state.dtype))
col_state.copy_(col.to(col_state.dtype))
update = self._approx_sq_grad(row, col).mul_(grad)
else:
v_state = state["exp_avg_sq"]
if v_state.dtype == torch.float32:
v = v_state
v.mul_(beta2).add_(sq, alpha=1.0 - beta2)
else:
v = v_state.to(torch.float32)
v.mul_(beta2).add_(sq, alpha=1.0 - beta2)
v_state.copy_(v.to(v_state.dtype))
update = v.rsqrt().mul_(grad)
update.div_((self._rms(update) / group["clip_threshold"]).clamp_(min=1.0))
# Per-element sign agreement collapsed to a single bump decision.
# Kept on-device as a 0-D tensor to avoid a CPU<->GPU sync in the hot path.
cur_polarity = update > 0
last_polarity = state["last_polarity"]
agreement = (cur_polarity == last_polarity).to(torch.float32).mean()
state["last_polarity"] = cur_polarity
lr_t = state["lr"]
if state["step"] > 0:
direction = (agreement >= group["agreement_threshold"]).to(lr_t.dtype) * 2.0 - 1.0
lr_t.add_(direction, alpha=group["lr_bump"]).clamp_(
min=group["min_lr"], max=group["max_lr"]
)
state["step"] += 1
update.mul_(lr_t)
wd = group["weight_decay"]
if p.dtype == torch.bfloat16:
# Single bf16 -> fp32 conversion shared by weight decay and SR.
new_p_fp32 = p.to(torch.float32)
if wd != 0.0:
update.addcmul_(new_p_fp32, lr_t, value=wd)
new_p_fp32.sub_(update)
# Stochastic rounding fp32 -> bf16: add random noise into the lower
# 16 mantissa bits, then truncate. Done in place on new_p_fp32 so
# we don't allocate a separate int32 work buffer.
as_int = new_p_fp32.view(torch.int32)
as_int.add_(torch.randint_like(as_int, 1 << 16)).bitwise_and_(-65536)
p.copy_(new_p_fp32)
else:
if wd != 0.0:
p_fp32 = p if p.dtype == torch.float32 else p.to(torch.float32)
update.addcmul_(p_fp32, lr_t, value=wd)
p.add_(update.to(p.dtype), alpha=-1.0)
p.grad = None
# ----------------------------------------------------------- optimizer API
@torch.no_grad()
def step(self, closure=None):
loss = None
if closure is not None:
with torch.enable_grad():
loss = closure()
return loss
def get_learning_rates(self) -> List[float]:
out = []
for group in self.param_groups:
lrs = [
float(self.state[p]["lr"])
for p in group["params"]
if p in self.state and "lr" in self.state[p]
]
out.append(sum(lrs) / len(lrs) if lrs else float(group["lr"]))
return out
def get_avg_learning_rate(self) -> float:
lrs = self.get_learning_rates()
return sum(lrs) / len(lrs) if lrs else float(self.defaults["lr"])
def load_state_dict(self, state_dict):
# Parent casts every fp state tensor to param.dtype; force lr back to fp32
# so subsequent lr_bump (default 1e-6) isn't rounded away on bf16 weights.
super().load_state_dict(state_dict)
# Constructor args always win over whatever was saved in the checkpoint.
for group in self.param_groups:
for k, v in self.defaults.items():
group[k] = v
for p in group["params"]:
st = self.state.get(p)
if st is not None and isinstance(st.get("lr"), torch.Tensor):
st["lr"] = st["lr"].to(torch.float32)
|