| from __future__ import annotations |
|
|
| import json |
| import os |
| import random |
| import uuid |
| from pathlib import Path |
| from typing import Any |
|
|
| import numpy as np |
| import torch |
|
|
|
|
| def resolve_checkpoint(resume: str | Path, output_dir: str | Path) -> Path: |
| if str(resume).lower() != "latest": |
| path = Path(resume) |
| else: |
| latest_file = Path(output_dir) / "latest_checkpoint.txt" |
| if not latest_file.is_file(): |
| raise FileNotFoundError( |
| f"Cannot resume latest: {latest_file} does not exist" |
| ) |
| stored = latest_file.read_text(encoding="utf-8").strip() |
| path = Path(stored) |
| if not path.is_absolute(): |
| path = Path(output_dir) / path |
| if not (path / "model").is_dir() or not (path / "trainer_state.pt").is_file(): |
| raise FileNotFoundError(f"Invalid checkpoint directory: {path}") |
| return path.resolve() |
|
|
|
|
| def capture_rng_state() -> dict[str, Any]: |
| state: dict[str, Any] = { |
| "python": random.getstate(), |
| "numpy": np.random.get_state(), |
| "torch": torch.get_rng_state(), |
| } |
| if torch.cuda.is_available(): |
| state["cuda"] = torch.cuda.get_rng_state_all() |
| return state |
|
|
|
|
| def restore_rng_state(state: dict[str, Any]) -> None: |
| random.setstate(state["python"]) |
| np.random.set_state(state["numpy"]) |
| torch.set_rng_state(state["torch"]) |
| if torch.cuda.is_available() and "cuda" in state: |
| torch.cuda.set_rng_state_all(state["cuda"]) |
|
|
|
|
| def load_training_state(path: Path) -> dict[str, Any]: |
| try: |
| return torch.load(path, map_location="cpu", weights_only=False) |
| except TypeError: |
| return torch.load(path, map_location="cpu") |
|
|
|
|
| def save_checkpoint( |
| *, |
| output_dir: Path, |
| step: int, |
| model: Any, |
| tokenizer: Any, |
| optimizer: torch.optim.Optimizer, |
| scheduler: Any, |
| training_config: dict[str, Any], |
| world_size: int, |
| ) -> Path: |
| output_dir.mkdir(parents=True, exist_ok=True) |
| final_path = output_dir / f"checkpoint-{step:08d}" |
| if final_path.exists(): |
| return final_path |
|
|
| temporary_path = output_dir / f".checkpoint-{step:08d}-{uuid.uuid4().hex}.tmp" |
| temporary_path.mkdir(parents=False, exist_ok=False) |
| try: |
| model.save_pretrained( |
| temporary_path / "model", |
| safe_serialization=True, |
| max_shard_size="2GB", |
| ) |
| tokenizer.save_pretrained(temporary_path / "tokenizer") |
| state = { |
| "step": step, |
| "world_size": world_size, |
| "optimizer": optimizer.state_dict(), |
| "scheduler": scheduler.state_dict(), |
| "rng": capture_rng_state(), |
| "training_config": training_config, |
| } |
| torch.save(state, temporary_path / "trainer_state.pt") |
| with (temporary_path / "state_summary.json").open( |
| "w", encoding="utf-8" |
| ) as handle: |
| json.dump( |
| {"step": step, "world_size": world_size}, |
| handle, |
| ensure_ascii=False, |
| indent=2, |
| ) |
| handle.write("\n") |
| os.replace(temporary_path, final_path) |
| except BaseException: |
| |
| raise |
|
|
| latest_temp = output_dir / ".latest_checkpoint.tmp" |
| latest_temp.write_text(final_path.name + "\n", encoding="utf-8") |
| os.replace(latest_temp, output_dir / "latest_checkpoint.txt") |
| return final_path |
|
|
|
|
