Download playground/Abbie-b200/tests/shared/optimizer.py from jasonfan/devboxbackup: direct link, hf CLI and curl.
- Browser
- Download file 4.26 kB
-
https://huggingface.co/datasets/jasonfan/devboxbackup/resolve/main/playground/Abbie-b200/tests/shared/optimizer.py
- Command line
-
hf download hf://datasets/jasonfan/devboxbackup/playground/Abbie-b200/tests/shared/optimizer.py
-
curl -L -o optimizer.py https://huggingface.co/datasets/jasonfan/devboxbackup/resolve/main/playground/Abbie-b200/tests/shared/optimizer.py
4.26 kB
| from typing import Dict | |
| import torch | |
| import math | |
| from torch.distributed.optim import ZeroRedundancyOptimizer | |
| # ----------------------------- configurable hyper-params ----------------------------- | |
| total_steps = 50000 # how many optimiser.step() calls you expect | |
| warmup_steps = 200 # ≈ 1-3 % of total_steps is typical | |
| lr_max = 3e-4 # peak LR (your “LRmax”) | |
| lr_min = 3e-5 # final LR (usually 0.05-0.1 × lr_max) | |
| hold_steps = 0 # optional: keep lr_min flat for the last N steps | |
| # --------------------------------------------------------------------------------------- | |
| def lr_lambda(current_step: int): | |
| """ | |
| 0-----warm-up----------cosine----------flat--> 1 (returns *multiplicative* factor) | |
| """ | |
| if current_step < warmup_steps: # linear warm-up | |
| return float(current_step) / float(max(1, warmup_steps)) | |
| progress = (current_step - warmup_steps) / float(max(1, total_steps - warmup_steps - hold_steps)) | |
| progress = min(progress, 1.0) # clip in case total_steps not precise | |
| if current_step < total_steps - hold_steps: # cosine decay | |
| cosine = 0.5 * (1.0 + math.cos(math.pi * progress)) | |
| return cosine * (lr_max - lr_min) / lr_max + lr_min / lr_max | |
| return lr_min / lr_max # flat tail | |
| def get_lr_lambda(constant: bool): | |
| if constant: | |
| return lambda _: lr_max | |
| else: | |
| return lr_lambda | |
| def build_optimizer(rank, world_size, module, dp_group, zero_redundant=False): | |
| master_params = [] | |
| param_to_master_param = {} | |
| name_to_param_and_master_param = {} | |
| for name, param in module.named_parameters(): | |
| # Master gradient | |
| print(f"[Rank-{rank}] GRAD_ACC, param name: {name} size: {param.shape} require_grad: {param.requires_grad}") | |
| #p = param.detach().clone().float().requires_grad_() | |
| p = torch.empty_like(param, dtype=torch.float32) | |
| # Allocation of parameter's so called "main_grad" | |
| # In TE Linear core (functors) they are just accumulated directly. | |
| param.main_grad = p | |
| master_params.append(p) | |
| param_to_master_param[param] = p | |
| name_to_param_and_master_param[name] = (param, p) | |
| if world_size > 1 or zero_redundant: | |
| optimizer = ZeroRedundancyOptimizer( | |
| module.parameters(), # Still using old module's params. | |
| optimizer_class=torch.optim.AdamW, | |
| lr=lr_max, | |
| weight_decay=0.1, | |
| betas=(0.9, 0.95), | |
| process_group=dp_group, | |
| ) | |
| else: | |
| optimizer = torch.optim.AdamW(master_params, lr=lr_max, betas=(0.9, 0.95), weight_decay=0.1) | |
| # opt_param_scheduler = get_optimizer_param_scheduler(optimizer) | |
| print( | |
| f"Allocated CUDA Memory after configure optimizer: {torch.cuda.memory_allocated() / 1000.0 / 1000 / 1000} GB") | |
| return optimizer, master_params, param_to_master_param, name_to_param_and_master_param | |
| # This shall be booked mainly for optimizer to work. | |
| def copy_back_grads(name_to_param_and_master_param): | |
| with torch.no_grad(): | |
| for name, (p_bf16, p32_as_grad) in name_to_param_and_master_param.items(): | |
| if p_bf16.grad is None: | |
| p_bf16.grad = p32_as_grad.bfloat16().clone() | |
| else: | |
| p_bf16.grad.copy_(p32_as_grad.bfloat16()) | |
| #assert p_bf16.grad.type() == 'torch.cuda.HalfTensor' | |
| #assert p_bf16.grad.type() == 'torch.cuda.BFloat16Tensor' | |
| def zero_out_master_grads(name_to_param_and_master_param): | |
| print(f"Zeroing out accumulated master grad") | |
| with torch.no_grad(): | |
| for name, (p_bf16, p32_grad) in name_to_param_and_master_param.items(): | |
| if p_bf16.grad is not None: | |
| p_bf16.grad = None | |
| p32_grad.zero_() | |
| def sample_check_pow2_grad(module): | |
| grads = [] | |
| total_grad = 0.0 | |
| for n, param in module.named_parameters(): | |
| if param.main_grad is not None: | |
| copied = param.main_grad.clone().detach() | |
| else: | |
| copied = param.grad.clone().detach() | |
| total_grad += copied.pow(2).sum() | |
| #assert param.grad.type() == 'torch.cuda.FloatTensor' | |
| print(f"{n} param shape: {copied.shape} grad mean: {copied.mean()} pow_2_sum: {copied.pow(2).sum()}") | |
| grads.append(copied) | |