| |
| |
|
|
| import torch |
| from transformers import ( |
| get_constant_schedule_with_warmup, |
| get_cosine_schedule_with_warmup, |
| get_linear_schedule_with_warmup, |
| ) |
| import torch.distributed as dist |
| import os |
| from rich import print |
| import traceback |
| from torch.nn.parallel import DistributedDataParallel as DDP |
| import torch.distributed as dist |
| import gc |
|
|
| def is_dist_avail_and_initialized(): |
| return dist.is_available() and dist.is_initialized() |
|
|
| def print_rank0(*args, **kwargs): |
| if dist.is_initialized(): |
| if dist.get_rank() == 0: |
| print(*args, **kwargs) |
| else: |
| print(*args, **kwargs) |
|
|
|
|
| def format_number(num): |
| if num >= 1_000_000_000: |
| return f"{num / 1_000_000_000:.2f}B" |
| elif num >= 1_000_000: |
| return f"{num / 1_000_000:.2f}M" |
| elif num >= 1_000: |
| return f"{num / 1_000:.2f}K" |
| return str(num) |
|
|
| def create_optimizer(model, weight_decay, learning_rate, betas): |
| all_param_dict = {name: param for name, param in model.named_parameters()} |
| optimized_param_dict = {name: param for name, param in all_param_dict.items() if param.requires_grad} |
|
|
| decay_params, nodecay_params = [], [] |
| for name, param in optimized_param_dict.items(): |
| if param.dim() == 1 or getattr(param, '_no_weight_decay', False): |
| nodecay_params.append(param) |
| else: |
| decay_params.append(param) |
| optim_groups = [ |
| {'params': decay_params, 'weight_decay': weight_decay}, |
| {'params': nodecay_params, 'weight_decay': 0.0} |
| ] |
| optimizer = torch.optim.AdamW(optim_groups, lr=learning_rate, betas=betas,fused=True) |
| |
| if is_dist_avail_and_initialized(): |
| if dist.get_rank() == 0: |
| def get_module_name(name): |
| parts = name.split('.') |
| if len(parts) > 2 and parts[0] == 'module': |
| return parts[1] + '.' + parts[2] |
| return parts[0] |
| print(f'Optimizer: AdamW, learning rate: {learning_rate}, weight_decay: {weight_decay}, betas: {betas}') |
| total_params = sum(p.numel() for p in model.parameters()) |
| trainable_params = sum(p.numel() for p in optimized_param_dict.values()) |
| optim_module_names = sorted(set(get_module_name(name) for name in optimized_param_dict.keys())) |
| frozen_module_names = sorted(set(get_module_name(name) for name in set(all_param_dict.keys()) - set(optimized_param_dict.keys()))) |
| |
| print(f'Total parameters: {format_number(total_params)}, Trainable parameters: {format_number(trainable_params)}') |
| print(f'Optimized parameters: {optim_module_names}') |
| print(f'Frozen parameters: {frozen_module_names}') |
| |
| return optimizer, optimized_param_dict, all_param_dict |
|
|
| def create_lr_scheduler(optimizer, param_update_steps, warm_up_steps, scheduler_type='cosine'): |
| if scheduler_type == 'linear': |
| scheduler = get_linear_schedule_with_warmup(optimizer, warm_up_steps, param_update_steps) |
| elif scheduler_type == 'cosine': |
| scheduler = get_cosine_schedule_with_warmup(optimizer, warm_up_steps, param_update_steps) |
| elif scheduler_type == 'constant': |
| scheduler = get_constant_schedule_with_warmup(optimizer, warm_up_steps) |
| else: |
| raise ValueError(f'Invalid scheduler type: {scheduler_type}') |
| return scheduler |
|
|
|
|
|
|
| def find_checkpoints(load_path): |
| if os.path.isdir(load_path): |
| ckpt_names = [file_name for file_name in os.listdir(load_path) if file_name.endswith(".pt")] |
| ckpt_names = sorted(ckpt_names, key=lambda x: x) |
| ckpt_paths = [os.path.join(load_path, ckpt_name) for ckpt_name in ckpt_names] |
| else: |
| if load_path.endswith(".pt"): |
| ckpt_paths = [load_path] |
| else: |
| ckpt_paths = [] |
| return ckpt_paths |
|
|
|
|
|
|
| def auto_resume_job( |
| load_path, |
| model, |
| optimizer, |
| lr_scheduler, |
| reset_training_state |
| ): |
| """ |
| Resume training from the latest checkpoint in the specified directory. |
| Returns the fwdbwd_pass_step and param_update_step. |
| |
| Args: |
| load_path: If dir, load the last checkpoint in the directory. |
| O.w., assume it's a ckpt and load it. |
| model: model to be loaded |
| optimizer: optimizer to be loaded |
| lr_scheduler: lr scheduler to be loaded |
| reset_training_state: whether to reset the training state |
| |
| Returns: |
| optimizer, lr_scheduler, forward_pass_step, param_update_step |
| |
| """ |
| forward_pass_step = 0 |
| param_update_step = 0 |
| all_ckpt_paths = find_checkpoints(load_path) |
| if len(all_ckpt_paths) == 0: |
| print_rank0(f"No checkpoint found in {load_path}, we will start from scratch") |
| return optimizer, lr_scheduler, forward_pass_step, param_update_step |
| try: |
| ckpt_path = all_ckpt_paths[-1] |
| checkpoint = torch.load(ckpt_path, map_location="cpu") |
| except: |
| traceback.print_exc() |
| print_rank0(f"Failed to load {ckpt_path}, we will start from scratch") |
| return optimizer, lr_scheduler, forward_pass_step, param_update_step |
|
|
| |
| if isinstance(model, DDP): |
| status = model.module.load_state_dict(checkpoint['model'], strict=False) |
| else: |
| status = model.load_state_dict(checkpoint['model'], strict=False) |
| print_rank0(f"Loaded model from {os.path.abspath(ckpt_path)}, the status is {status}") |
|
|
| if not reset_training_state: |
| try: |
| optimizer.load_state_dict(checkpoint["optimizer"]) |
| lr_scheduler.load_state_dict(checkpoint["lr_scheduler"]) |
| forward_pass_step = checkpoint["fwdbwd_pass_step"] |
| param_update_step = checkpoint["param_update_step"] |
| print_rank0(f"Resumed optimizer and lr_scheduler from {ckpt_path}") |
| except: |
| traceback.print_exc() |
| print_rank0(f"Failed to load optimizer and lr_scheduler from {ckpt_path}") |
| |
| return optimizer, lr_scheduler, forward_pass_step, param_update_step |
|
|
|
|
| def check_and_handle_global_nan_loss(loss, ddp_info, cur_train_step, grad_accum_steps, total_train_steps, |
| ret_dict, batch, lr_scheduler, optimizer): |
| """ |
| Check if loss contains NaN/Inf values and handle cleanup if detected. |
| |
| Args: |
| loss: The loss tensor to check |
| ddp_info: Distributed training info object with is_distributed, device, etc. |
| cur_train_step: Current training step |
| grad_accum_steps: Gradient accumulation steps |
| total_train_steps: Total training steps |
| ret_dict: Return dictionary from model forward pass |
| batch: Input batch |
| lr_scheduler: Learning rate scheduler |
| optimizer: Optimizer |
| |
| Returns: |
| bool: True if NaN/Inf was detected and cleanup was performed, False otherwise |
| """ |
| loss_is_nan = torch.isnan(loss) or torch.isinf(loss) |
| if ddp_info.is_distributed: |
| has_nan_tensor = torch.tensor(float(loss_is_nan), device=ddp_info.device) |
| dist.all_reduce(has_nan_tensor, op=dist.ReduceOp.MAX) |
| global_has_nan = has_nan_tensor.item() > 0.5 |
| else: |
| global_has_nan = loss_is_nan |
|
|
| if global_has_nan: |
| print_rank0(f"Step {cur_train_step}: Detected NaN/Inf loss on at least one rank. Skipping backward and optimizer step for all ranks.") |
| if (cur_train_step + 1) % grad_accum_steps == 0 or cur_train_step == total_train_steps: |
| print(f"Zeroing grads for step {cur_train_step}") |
| |
| def deep_detach(obj): |
| if isinstance(obj, torch.Tensor): |
| return obj.detach() |
| elif isinstance(obj, dict): |
| return {k: deep_detach(v) for k, v in obj.items()} |
| elif isinstance(obj, (list, tuple)): |
| return type(obj)(deep_detach(item) for item in obj) |
| elif hasattr(obj, '__dict__'): |
| for k, v in obj.__dict__.items(): |
| setattr(obj, k, deep_detach(v)) |
| return obj |
| else: |
| return obj |
|
|
| with torch.no_grad(): |
| ret_dict = deep_detach(ret_dict) |
|
|
| del ret_dict |
| del batch |
| lr_scheduler.step() |
| optimizer.zero_grad(set_to_none=True) |
| gc.collect() |
| torch.cuda.empty_cache() |
| |
| if ddp_info.is_distributed: |
| dist.barrier() |
| |
| return True |
| |
| return False |
|
|
|
|
|
|
