File size: 5,789 Bytes
32da3e8 | 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 | """Optimizer and scheduler utilities using typed configs."""
from __future__ import annotations
import math
from typing import Any, Dict, Iterable, Optional
import torch
from torch.optim import Optimizer
from torch.optim.lr_scheduler import LambdaLR
from configs import OptimizerConfig, SchedulerConfig
class MuonAdamW(Optimizer):
"""Composite optimizer: Muon for 2D params, AdamW for the rest."""
def __init__(self, muon_opt: Optimizer, adamw_opt: Optimizer):
self._muon = muon_opt
self._adamw = adamw_opt
self.param_groups = muon_opt.param_groups + adamw_opt.param_groups
self.defaults: Dict[str, Any] = {}
@property
def state(self) -> Dict:
merged: Dict = {}
merged.update(self._muon.state)
merged.update(self._adamw.state)
return merged
def zero_grad(self, set_to_none: bool = False) -> None:
self._muon.zero_grad(set_to_none=set_to_none)
self._adamw.zero_grad(set_to_none=set_to_none)
@torch.no_grad()
def step(self, closure=None) -> None:
self._muon.step(closure=closure)
self._adamw.step(closure=closure)
def state_dict(self) -> Dict[str, Any]:
return {"muon": self._muon.state_dict(), "adamw": self._adamw.state_dict()}
def load_state_dict(self, state_dict: Dict[str, Any]) -> None:
self._muon.load_state_dict(state_dict["muon"])
self._adamw.load_state_dict(state_dict["adamw"])
self.param_groups = self._muon.param_groups + self._adamw.param_groups
def build_optimizer(
parameters: Iterable[torch.nn.Parameter],
config: OptimizerConfig,
) -> tuple[Optimizer, str]:
"""Build optimizer from typed OptimizerConfig."""
if config.type == "adamw":
optimizer = torch.optim.AdamW(
parameters,
lr=config.lr,
betas=config.betas,
weight_decay=config.weight_decay,
eps=config.eps,
fused=True,
)
msg = f"AdamW(lr={config.lr}, betas={config.betas}, wd={config.weight_decay})"
elif config.type == "gmuon":
from gram_newton_schulz import Muon as GMuon
params_list = list(parameters)
muon_params = [p for p in params_list if p.ndim == 2]
fallback_params = [p for p in params_list if p.ndim != 2]
adamw_opt = torch.optim.AdamW(
fallback_params if fallback_params else [torch.nn.Parameter(torch.empty(0))],
lr=config.adamw_lr if config.adamw_lr is not None else config.lr,
betas=config.betas,
weight_decay=config.weight_decay,
eps=config.eps,
)
gmuon_opt = GMuon(
muon_params,
lr=config.lr,
momentum=config.momentum,
nesterov=config.nesterov,
weight_decay=config.weight_decay,
ns_coefficients_preset=config.ns_coefficients_preset,
ns_use_kernels=config.ns_use_kernels,
adjust_lr="rms_norm",
)
optimizer = MuonAdamW(gmuon_opt, adamw_opt)
msg = (f"GMuon(lr={config.lr}, momentum={config.momentum}, "
f"preset={config.ns_coefficients_preset}, kernels={config.ns_use_kernels}, "
f"{len(muon_params)} 2D params, {len(fallback_params)} fallback)")
else:
raise ValueError(f"Unsupported optimizer '{config.type}'. Choose from ['adamw', 'gmuon'].")
return optimizer, msg
def build_scheduler(
optimizer: Optimizer,
steps_per_epoch: int,
config: SchedulerConfig,
state_dict: Optional[Dict[str, Any]] = None,
) -> tuple[LambdaLR, str]:
"""Build LR scheduler from typed SchedulerConfig."""
# Compute steps from epochs or use direct step values
if config.warmup_steps is not None:
warmup_steps = config.warmup_steps
else:
warmup_steps = int(config.warmup_epochs * steps_per_epoch)
if config.decay_end_steps is not None:
decay_end_steps = config.decay_end_steps
else:
decay_end_steps = int(config.decay_end_epoch * steps_per_epoch)
warmup_steps = max(warmup_steps, 0)
decay_end_steps = max(decay_end_steps, warmup_steps)
total_decay_steps = max(decay_end_steps - warmup_steps, 1)
base_lr = config.base_lr
final_lr = config.final_lr
final_ratio = final_lr / base_lr if base_lr > 0 else 1.0
warmup_from_zero = config.warmup_from_zero
# Set optimizer LR to base_lr
for group in optimizer.param_groups:
if group.get('name') not in ('encoder', 'decoder'):
group["lr"] = base_lr
if config.type == "linear":
def lr_lambda(step: int) -> float:
if step < warmup_steps:
return (step + 1) / warmup_steps if warmup_from_zero else 1.0
if step >= decay_end_steps:
return final_ratio
progress = (step - warmup_steps) / total_decay_steps
return 1.0 - (1.0 - final_ratio) * progress
elif config.type == "cosine":
def lr_lambda(step: int) -> float:
if step < warmup_steps:
return (step + 1) / warmup_steps if warmup_from_zero else 1.0
if step >= decay_end_steps:
return final_ratio
progress = (step - warmup_steps) / total_decay_steps
cosine = 0.5 * (1.0 + math.cos(math.pi * progress))
return final_ratio + (1.0 - final_ratio) * cosine
else:
raise ValueError(f"Unsupported scheduler '{config.type}'. Choose from ['linear', 'cosine'].")
scheduler = LambdaLR(optimizer, lr_lambda=lr_lambda)
if state_dict is not None:
scheduler.load_state_dict(state_dict)
msg = f"{config.type}(warmup={warmup_steps}, decay_end={decay_end_steps}, lr={base_lr}->{final_lr})"
return scheduler, msg
|