File size: 3,062 Bytes
4ec41f2 | 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 | 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
|