| import gc, os, torch |
| from accelerate import Accelerator |
| from safetensors.torch import save_file |
|
|
|
|
| class ModelLogger: |
| def __init__(self, output_path, remove_prefix_in_ckpt=None, state_dict_converter=lambda x:x): |
| self.output_path = output_path |
| self.remove_prefix_in_ckpt = remove_prefix_in_ckpt |
| self.state_dict_converter = state_dict_converter |
| self.num_steps = 0 |
|
|
|
|
| def on_step_end(self, accelerator: Accelerator, model: torch.nn.Module, save_steps=None, **kwargs): |
| self.num_steps += 1 |
| loss = kwargs.get("loss") |
| if loss is not None and accelerator.is_main_process: |
| print(f"[step {self.num_steps}] loss={loss.item():.6f}", flush=True) |
| if save_steps is not None and self.num_steps % save_steps == 0: |
| self.save_model(accelerator, model, f"step-{self.num_steps}.safetensors") |
|
|
|
|
| def on_epoch_end(self, accelerator: Accelerator, model: torch.nn.Module, epoch_id): |
| self.save_model(accelerator, model, f"epoch-{epoch_id}.safetensors") |
|
|
|
|
| def on_training_end(self, accelerator: Accelerator, model: torch.nn.Module, save_steps=None): |
| if save_steps is not None and self.num_steps % save_steps != 0: |
| self.save_model(accelerator, model, f"step-{self.num_steps}.safetensors") |
|
|
|
|
| def save_model(self, accelerator: Accelerator, model: torch.nn.Module, file_name): |
| accelerator.wait_for_everyone() |
| if accelerator.is_main_process: |
| state_dict = self._export_trainable_state_dict(accelerator, model) |
| state_dict = self.state_dict_converter(state_dict) |
| os.makedirs(self.output_path, exist_ok=True) |
| path = os.path.join(self.output_path, file_name) |
| tmp_path = f"{path}.tmp" |
| save_file(state_dict, tmp_path) |
| os.replace(tmp_path, path) |
| param_count = sum(tensor.numel() for tensor in state_dict.values()) |
| size_gib = sum(tensor.numel() * tensor.element_size() for tensor in state_dict.values()) / (1024 ** 3) |
| print( |
| f"[Checkpoint] saved {path} tensors={len(state_dict)} " |
| f"params={param_count:,} size={size_gib:.2f} GiB", |
| flush=True, |
| ) |
| del state_dict |
| gc.collect() |
| accelerator.wait_for_everyone() |
|
|
|
|
| def _export_trainable_state_dict(self, accelerator: Accelerator, model: torch.nn.Module): |
| module = accelerator.unwrap_model(model) |
| state_dict = {} |
| for name, param in module.named_parameters(): |
| if not param.requires_grad: |
| continue |
| key = name |
| if self.remove_prefix_in_ckpt is not None and key.startswith(self.remove_prefix_in_ckpt): |
| key = key[len(self.remove_prefix_in_ckpt):] |
| tensor = param.detach() |
| if tensor.device.type == "cpu": |
| tensor = tensor.clone() |
| else: |
| tensor = tensor.to(device="cpu") |
| state_dict[key] = tensor.contiguous() |
| return state_dict |
|
|
