Upload scripts/train_agnostic.py with huggingface_hub

0423e20 verified 5 days ago

16.1 kB

#!/usr/bin/env python3
"""Hardware-agnostic Pear1.5 training script.
Auto-detects hardware (CUDA/TPU/CPU), configures optimal settings,
and runs training. Can resume from ANY checkpoint regardless of origin hardware.
Usage:
    python train_agnostic.py --data-path /path/to/data --output-dir /path/to/checkpoints
    python train_agnostic.py --data-path /path/to/data --output-dir /path/to/checkpoints --resume-from step_88587
    python train_agnostic.py --data-path /path/to/data --output-dir /path/to/checkpoints --resume-from /path/to/checkpoint.pt
"""
import argparse
import json
import math
import os
import sys
import time
import hashlib
from pathlib import Path
from typing import Optional, Dict, Any

import torch
import torch.nn as nn
from torch.utils.data import DataLoader

# Import hardware detection
sys.path.insert(0, str(Path(__file__).parent))
from hardware import get_hardware_info, get_training_config, HardwareInfo, DeviceType

# Constants
PARENT_STEP = 18666
PARENT_TOKENS = 1_739_227_136
TOKENS_PER_STEP = 16_384
TARGET = 50_000_000_000
DATA_FP = '03b6dc7f4e70ae679d84da9407dafaaf6b9e0abb79634ef9b95a34044397a553'
IMPLEMENTATION_FP = 'ef9af3b58d70b42a123ba689f4d88de267cbac4c2ba1eae2838bdb57d2b8a36d'

# Model constants (for reference)
VOCAB = 49152
HIDDEN = 576
LAYERS = 30
HEADS = 9
KV_HEADS = 3


def build_model(config: Dict[str, Any]) -> nn.Module:
    """Build Llama model from config dict."""
    from transformers import LlamaConfig, LlamaForCausalLM
    
    llama_config = LlamaConfig(
        vocab_size=config["vocab_size"],
        hidden_size=config["hidden_size"],
        num_hidden_layers=config["num_hidden_layers"],
        num_attention_heads=config["num_attention_heads"],
        num_key_value_heads=config["num_key_value_heads"],
        max_position_embeddings=config["max_position_embeddings"],
        rope_theta=config.get("rope_theta", 10000.0),
        tie_word_embeddings=config.get("tie_word_embeddings", True),
        hidden_act="silu",
        initializer_range=0.02,
        rms_norm_eps=1e-5,
        use_cache=False,  # Required for gradient checkpointing
    )
    model = LlamaForCausalLM(llama_config)
    return model


def load_checkpoint(model: nn.Module, optimizer, scheduler, ckpt_path: Path, device) -> Dict:
    """Load checkpoint from any hardware origin. Returns training state."""
    print(f"Loading checkpoint from {ckpt_path}")
    payload = torch.load(ckpt_path, map_location="cpu", weights_only=True)
    
    # Load model weights
    model.load_state_dict(payload["model"], strict=True)
    
    # Load optimizer/scheduler if present
    if optimizer and "optimizer" in payload:
        optimizer.load_state_dict(payload["optimizer"])
    if scheduler and "scheduler" in payload and payload["scheduler"]:
        scheduler.load_state_dict(payload["scheduler"])
    
    # Move model to device
    model.to(device)
    
    # Extract training state
    state = {
        "step": payload.get("step", 0),
        "token_count": payload.get("token_count", 0),
        "data_cursor": payload.get("data_cursor", {"epoch": 0, "offset_tokens": 0}),
    }
    
    print(f"Resumed from step {state['step']}, tokens {state['token_count']:,}")
    return state


def save_checkpoint(model, optimizer, scheduler, step: int, token_count: int, 
                    data_cursor: Dict, config: Dict, output_dir: Path, 
                    is_final: bool = False, hw: HardwareInfo = None) -> Path:
    """Save checkpoint in hardware-agnostic format."""
    output_dir.mkdir(parents=True, exist_ok=True)
    
    payload = {
        "model": model.state_dict(),
        "optimizer": optimizer.state_dict() if optimizer else None,
        "scheduler": scheduler.state_dict() if scheduler else None,
        "step": step,
        "token_count": token_count,
        "data_cursor": data_cursor,
        "model_config": {
            "model_type": config["model_type"],
            "vocab_size": config["vocab_size"],
            "hidden_size": config["hidden_size"],
            "num_hidden_layers": config["num_hidden_layers"],
            "num_attention_heads": config["num_attention_heads"],
            "num_key_value_heads": config["num_key_value_heads"],
            "max_position_embeddings": config["max_position_embeddings"],
            "tie_word_embeddings": config.get("tie_word_embeddings", True),
        },
        "training_config": {k: v for k, v in config.items() 
                           if k not in ["model_type", "vocab_size", "hidden_size", 
                                       "num_hidden_layers", "num_attention_heads", 
                                       "num_key_value_heads", "max_position_embeddings",
                                       "tie_word_embeddings"]},
        "hardware_origin": {
            "device_type": hw.device_type.value if hw else "unknown",
            "variant": hw.variant if hw else "unknown",
            "num_devices": hw.num_devices if hw else 1,
        } if hw else {},
        "identity": {
            "implementation_fingerprint": IMPLEMENTATION_FP,
            "dataset_fingerprint": DATA_FP,
            "model_fingerprint": "",  # TODO: compute
        },
        "rng": {
            "torch": torch.get_rng_state(),
            "cuda": torch.cuda.get_rng_state_all() if torch.cuda.is_available() else None,
        },
    }
    
    step_str = f"step_{step:012d}"
    ckpt_dir = output_dir / step_str
    ckpt_dir.mkdir(parents=True, exist_ok=True)
    
    ckpt_path = ckpt_dir / "checkpoint.pt"
    torch.save(payload, ckpt_path)
    
    # Manifest
    manifest = {
        "format": "pear15.cloud_checkpoint.v1",
        "file": "checkpoint.pt",
        "sha256": hashlib.sha256(ckpt_path.read_bytes()).hexdigest(),
        "bytes": ckpt_path.stat().st_size,
        "step": step,
        "created_ns": time.time_ns(),
        "id": hashlib.sha256(f"{step}{time.time_ns()}".encode()).hexdigest()[:32],
    }
    (ckpt_dir / "manifest.json").write_text(json.dumps(manifest, indent=2, sort_keys=True))
    
    # READY marker
    ready = b"pear15.cloud_checkpoint.v1\n" + manifest["sha256"].encode() + b"\n"
    (ckpt_dir / "READY").write_bytes(ready)
    
    print(f"Saved checkpoint: {ckpt_dir}")
    return ckpt_dir


def get_dataloader(data_path: Path, config: Dict, device, hw: HardwareInfo):
    """Get DataLoader for the detected hardware.
    
    REPLACE THIS with your actual data loader from pear15.scratch_data
    """
    # For now, use a dummy loader - REPLACE WITH REAL DATA
    from torch.utils.data import DataLoader, TensorDataset, IterableDataset
    
    class DummyIterableDataset(IterableDataset):
        def __iter__(self):
            while True:
                input_ids = torch.randint(0, VOCAB, (config["batch_size"], config["sequence_length"]), dtype=torch.long)
                labels = input_ids.clone()
                yield input_ids, labels
    
    dataset = DummyIterableDataset()
    loader = DataLoader(dataset, batch_size=None, num_workers=0)
    
    if hw.device_type == DeviceType.TPU:
        import torch_xla.distributed.parallel_loader as pl
        return pl.MpDeviceLoader(loader, device)
    elif hw.device_type == DeviceType.CUDA and hw.num_devices > 1:
        # DDP handled separately
        return loader
    return loader


def train_loop(model, optimizer, scheduler, dataloader, device, config, 
               start_state, output_dir, hw, max_steps=None):
    """Main training loop."""
    model.train()
    
    step = start_state["step"]
    token_count = start_state["token_count"]
    data_cursor = start_state["data_cursor"]
    
    total_steps = config["total_steps"] if max_steps is None else min(config["total_steps"], start_state["step"] + max_steps)
    grad_accum = config["gradient_accumulation_steps"]
    log_interval = config["log_interval_steps"]
    ckpt_interval = config["checkpoint_interval_steps"]
    ckpt_interval_sec = config["checkpoint_interval_seconds"]
    
    optimizer.zero_grad()
    accumulated_loss = 0.0
    last_ckpt_time = time.time()
    
    print(f"Starting training from step {step} to {total_steps}")
    print(f"Device: {device}, Hardware: {hw.variant}, Effective batch: {hw.effective_batch}")
    
    # For TPU
    is_tpu = hw.device_type == DeviceType.TPU
    if is_tpu:
        import torch_xla.core.xla_model as xm
    
    for epoch in range(10000):  # Large number, controlled by total_steps
        for batch_idx, (input_ids, labels) in enumerate(dataloader):
            if step >= total_steps:
                break
            
            input_ids = input_ids.to(device, non_blocking=True)
            labels = labels.to(device, non_blocking=True)
            
            # Forward
            outputs = model(input_ids=input_ids, labels=labels)
            loss = outputs.loss / grad_accum
            
            # Backward
            loss.backward()
            accumulated_loss += loss.item()
            
            # Optimizer step
            if (batch_idx + 1) % grad_accum == 0:
                # Gradient clipping
                torch.nn.utils.clip_grad_norm_(model.parameters(), config["max_grad_norm"])
                
                if is_tpu:
                    import torch_xla.core.xla_model as xm
                    xm.optimizer_step(optimizer)
                else:
                    optimizer.step()
                
                scheduler.step()
                optimizer.zero_grad()
                
                step += 1
                token_count += TOKENS_PER_STEP
                
                # Logging
                if step % log_interval == 0:
                    avg_loss = accumulated_loss / log_interval
                    lr = scheduler.get_last_lr()[0]
                    print(f"step {step:,} | tokens {token_count:,} | loss {avg_loss:.4f} | lr {lr:.2e}")
                    accumulated_loss = 0.0
                
                # Checkpoint (step-based)
                if step % ckpt_interval == 0:
                    data_cursor = {"epoch": epoch, "offset_tokens": token_count % 997_885_340}
                    save_checkpoint(model, optimizer, scheduler, step, token_count,
                                   data_cursor, config, output_dir, hw=hw)
                    last_ckpt_time = time.time()
                
                # Checkpoint (time-based)
                if time.time() - last_ckpt_time >= ckpt_interval_sec:
                    data_cursor = {"epoch": epoch, "offset_tokens": token_count % 997_885_340}
                    save_checkpoint(model, optimizer, scheduler, step, token_count,
                                   data_cursor, config, output_dir, hw=hw)
                    last_ckpt_time = time.time()
        
        if step >= total_steps:
            break
    
    # Final checkpoint
    data_cursor = {"epoch": epoch, "offset_tokens": token_count % 997_885_340}
    save_checkpoint(model, optimizer, scheduler, step, token_count,
                   data_cursor, config, output_dir, is_final=True, hw=hw)
    
    if is_tpu:
        import torch_xla.core.xla_model as xm
        xm.wait_device_ops()
    
    return step, token_count


def setup_device(hw: HardwareInfo):
    """Setup device for training."""
    if hw.device_type == DeviceType.CUDA:
        if hw.num_devices > 1:
            # DDP setup
            import torch.distributed as dist
            dist.init_process_group(backend="nccl")
            local_rank = int(os.environ.get("LOCAL_RANK", 0))
            device = torch.device(f"cuda:{local_rank}")
            torch.cuda.set_device(device)
        else:
            device = torch.device("cuda:0")
        # Enable TF32 for Ampere+
        if hw.supports_bf16:
            torch.backends.cuda.matmul.allow_tf32 = True
            torch.backends.cudnn.allow_tf32 = True
    
    elif hw.device_type == DeviceType.TPU:
        import torch_xla.core.xla_model as xm
        device = xm.xla_device()
        os.environ["PJRT_DEVICE"] = "TPU"
        os.environ["XLA_USE_BF16"] = "1"
    
    else:
        device = torch.device("cpu")
    
    return device


def setup_optimizer(model, config):
    """Setup optimizer and scheduler."""
    optimizer = torch.optim.AdamW(
        model.parameters(),
        lr=config["learning_rate"],
        betas=(config["adam_beta1"], config["adam_beta2"]),
        eps=config["adam_epsilon"],
        weight_decay=config["weight_decay"],
    )
    
    total_steps = config["total_steps"]
    warmup_steps = config["warmup_steps"]
    min_lr_ratio = config["min_lr_ratio"]
    
    def lr_lambda(current_step):
        if current_step < warmup_steps:
            return float(current_step + 1) / float(max(1, warmup_steps))
        progress = float(current_step - warmup_steps) / float(max(1, total_steps - warmup_steps))
        return max(min_lr_ratio, 1.0 - progress * (1.0 - min_lr_ratio))
    
    scheduler = torch.optim.lr_scheduler.LambdaLR(optimizer, lr_lambda)
    return optimizer, scheduler


def main():
    parser = argparse.ArgumentParser(description="Hardware-agnostic Pear1.5 training")
    parser.add_argument("--data-path", type=Path, required=True, help="Path to expanded dataset")
    parser.add_argument("--output-dir", type=Path, required=True, help="Checkpoint output directory")
    parser.add_argument("--resume-from", type=str, default=None, 
                        help="Resume from checkpoint (step number, 'latest', or path)")
    parser.add_argument("--max-steps", type=int, default=None, help="Max steps to run")
    parser.add_argument("--hf-model-path", type=Path, default=None, 
                        help="HF model path for fresh init (if not resuming)")
    parser.add_argument("--seed", type=int, default=0)
    args = parser.parse_args()
    
    torch.manual_seed(args.seed)
    
    # Detect hardware
    hw = get_hardware_info()
    config = get_training_config(hw)
    
    # Setup device
    device = setup_device(hw)
    
    # Build or load model
    if args.resume_from:
        # Resume from checkpoint
        model = build_model(config)
        optimizer, scheduler = setup_optimizer(model, config)
        
        if args.resume_from == "latest":
            # Find latest checkpoint in output_dir
            ckpts = sorted(args.output_dir.glob("step_*/checkpoint.pt"))
            if not ckpts:
                raise ValueError("No checkpoints found to resume from")
            ckpt_path = ckpts[-1]
        elif args.resume_from.isdigit():
            # Step number
            step = int(args.resume_from)
            ckpt_path = args.output_dir / f"step_{step:012d}" / "checkpoint.pt"
        else:
            ckpt_path = Path(args.resume_from)
        
        start_state = load_checkpoint(model, optimizer, scheduler, ckpt_path, device)
    
    else:
        # Fresh init from HF model or scratch
        if args.hf_model_path:
            from transformers import AutoModelForCausalLM
            print(f"Loading from HF model: {args.hf_model_path}")
            model = AutoModelForCausalLM.from_pretrained(
                args.hf_model_path, torch_dtype=torch.bfloat16 if hw.supports_bf16 else torch.float32, use_cache=False
            )
        else:
            model = build_model(config)
        
        model.gradient_checkpointing_enable()
        model.to(device)
        
        optimizer, scheduler = setup_optimizer(model, config)
        start_state = {"step": 0, "token_count": 0, "data_cursor": {"epoch": 0, "offset_tokens": 0}}
    
    # DDP wrap for multi-GPU
    if hw.device_type == DeviceType.CUDA and hw.num_devices > 1:
        model = torch.nn.parallel.DistributedDataParallel(model, device_ids=[device.index])
    
    # Data loader
    dataloader = get_dataloader(args.data_path, config, device, hw)
    
    # Train
    final_step, final_tokens = train_loop(
        model, optimizer, scheduler, dataloader, device, config,
        start_state, args.output_dir, hw, max_steps=args.max_steps
    )
    
    print(f"Training complete: step {final_step}, tokens {final_tokens:,}")


if __name__ == "__main__":
    main()

	#!/usr/bin/env python3
	"""Hardware-agnostic Pear1.5 training script.

	Auto-detects hardware (CUDA/TPU/CPU), configures optimal settings,
	and runs training. Can resume from ANY checkpoint regardless of origin hardware.

	Usage:
	python train_agnostic.py --data-path /path/to/data --output-dir /path/to/checkpoints
	python train_agnostic.py --data-path /path/to/data --output-dir /path/to/checkpoints --resume-from step_88587
	python train_agnostic.py --data-path /path/to/data --output-dir /path/to/checkpoints --resume-from /path/to/checkpoint.pt
	"""
	import argparse
	import json
	import math
	import os
	import sys
	import time
	import hashlib
	from pathlib import Path
	from typing import Optional, Dict, Any

	import torch
	import torch.nn as nn
	from torch.utils.data import DataLoader

	# Import hardware detection
	sys.path.insert(0, str(Path(__file__).parent))
	from hardware import get_hardware_info, get_training_config, HardwareInfo, DeviceType

	# Constants
	PARENT_STEP = 18666
	PARENT_TOKENS = 1_739_227_136
	TOKENS_PER_STEP = 16_384
	TARGET = 50_000_000_000
	DATA_FP = '03b6dc7f4e70ae679d84da9407dafaaf6b9e0abb79634ef9b95a34044397a553'
	IMPLEMENTATION_FP = 'ef9af3b58d70b42a123ba689f4d88de267cbac4c2ba1eae2838bdb57d2b8a36d'

	# Model constants (for reference)
	VOCAB = 49152
	HIDDEN = 576
	LAYERS = 30
	HEADS = 9
	KV_HEADS = 3


	def build_model(config: Dict[str, Any]) -> nn.Module:
	"""Build Llama model from config dict."""
	from transformers import LlamaConfig, LlamaForCausalLM

	llama_config = LlamaConfig(
	vocab_size=config["vocab_size"],
	hidden_size=config["hidden_size"],
	num_hidden_layers=config["num_hidden_layers"],
	num_attention_heads=config["num_attention_heads"],
	num_key_value_heads=config["num_key_value_heads"],
	max_position_embeddings=config["max_position_embeddings"],
	rope_theta=config.get("rope_theta", 10000.0),
	tie_word_embeddings=config.get("tie_word_embeddings", True),
	hidden_act="silu",
	initializer_range=0.02,
	rms_norm_eps=1e-5,
	use_cache=False, # Required for gradient checkpointing
	)
	model = LlamaForCausalLM(llama_config)
	return model


	def load_checkpoint(model: nn.Module, optimizer, scheduler, ckpt_path: Path, device) -> Dict:
	"""Load checkpoint from any hardware origin. Returns training state."""
	print(f"Loading checkpoint from {ckpt_path}")
	payload = torch.load(ckpt_path, map_location="cpu", weights_only=True)

	# Load model weights
	model.load_state_dict(payload["model"], strict=True)

	# Load optimizer/scheduler if present
	if optimizer and "optimizer" in payload:
	optimizer.load_state_dict(payload["optimizer"])
	if scheduler and "scheduler" in payload and payload["scheduler"]:
	scheduler.load_state_dict(payload["scheduler"])

	# Move model to device
	model.to(device)

	# Extract training state
	state = {
	"step": payload.get("step", 0),
	"token_count": payload.get("token_count", 0),
	"data_cursor": payload.get("data_cursor", {"epoch": 0, "offset_tokens": 0}),
	}

	print(f"Resumed from step {state['step']}, tokens {state['token_count']:,}")
	return state


	def save_checkpoint(model, optimizer, scheduler, step: int, token_count: int,
	data_cursor: Dict, config: Dict, output_dir: Path,
	is_final: bool = False, hw: HardwareInfo = None) -> Path:
	"""Save checkpoint in hardware-agnostic format."""
	output_dir.mkdir(parents=True, exist_ok=True)

	payload = {
	"model": model.state_dict(),
	"optimizer": optimizer.state_dict() if optimizer else None,
	"scheduler": scheduler.state_dict() if scheduler else None,
	"step": step,
	"token_count": token_count,
	"data_cursor": data_cursor,
	"model_config": {
	"model_type": config["model_type"],
	"vocab_size": config["vocab_size"],
	"hidden_size": config["hidden_size"],
	"num_hidden_layers": config["num_hidden_layers"],
	"num_attention_heads": config["num_attention_heads"],
	"num_key_value_heads": config["num_key_value_heads"],
	"max_position_embeddings": config["max_position_embeddings"],
	"tie_word_embeddings": config.get("tie_word_embeddings", True),
	},
	"training_config": {k: v for k, v in config.items()
	if k not in ["model_type", "vocab_size", "hidden_size",
	"num_hidden_layers", "num_attention_heads",
	"num_key_value_heads", "max_position_embeddings",
	"tie_word_embeddings"]},
	"hardware_origin": {
	"device_type": hw.device_type.value if hw else "unknown",
	"variant": hw.variant if hw else "unknown",
	"num_devices": hw.num_devices if hw else 1,
	} if hw else {},
	"identity": {
	"implementation_fingerprint": IMPLEMENTATION_FP,
	"dataset_fingerprint": DATA_FP,
	"model_fingerprint": "", # TODO: compute
	},
	"rng": {
	"torch": torch.get_rng_state(),
	"cuda": torch.cuda.get_rng_state_all() if torch.cuda.is_available() else None,
	},
	}

	step_str = f"step_{step:012d}"
	ckpt_dir = output_dir / step_str
	ckpt_dir.mkdir(parents=True, exist_ok=True)

	ckpt_path = ckpt_dir / "checkpoint.pt"
	torch.save(payload, ckpt_path)

	# Manifest
	manifest = {
	"format": "pear15.cloud_checkpoint.v1",
	"file": "checkpoint.pt",
	"sha256": hashlib.sha256(ckpt_path.read_bytes()).hexdigest(),
	"bytes": ckpt_path.stat().st_size,
	"step": step,
	"created_ns": time.time_ns(),
	"id": hashlib.sha256(f"{step}{time.time_ns()}".encode()).hexdigest()[:32],
	}
	(ckpt_dir / "manifest.json").write_text(json.dumps(manifest, indent=2, sort_keys=True))

	# READY marker
	ready = b"pear15.cloud_checkpoint.v1\n" + manifest["sha256"].encode() + b"\n"
	(ckpt_dir / "READY").write_bytes(ready)

	print(f"Saved checkpoint: {ckpt_dir}")
	return ckpt_dir


	def get_dataloader(data_path: Path, config: Dict, device, hw: HardwareInfo):
	"""Get DataLoader for the detected hardware.

	REPLACE THIS with your actual data loader from pear15.scratch_data
	"""
	# For now, use a dummy loader - REPLACE WITH REAL DATA
	from torch.utils.data import DataLoader, TensorDataset, IterableDataset

	class DummyIterableDataset(IterableDataset):
	def __iter__(self):
	while True:
	input_ids = torch.randint(0, VOCAB, (config["batch_size"], config["sequence_length"]), dtype=torch.long)
	labels = input_ids.clone()
	yield input_ids, labels

	dataset = DummyIterableDataset()
	loader = DataLoader(dataset, batch_size=None, num_workers=0)

	if hw.device_type == DeviceType.TPU:
	import torch_xla.distributed.parallel_loader as pl
	return pl.MpDeviceLoader(loader, device)
	elif hw.device_type == DeviceType.CUDA and hw.num_devices > 1:
	# DDP handled separately
	return loader
	return loader


	def train_loop(model, optimizer, scheduler, dataloader, device, config,
	start_state, output_dir, hw, max_steps=None):
	"""Main training loop."""
	model.train()

	step = start_state["step"]
	token_count = start_state["token_count"]
	data_cursor = start_state["data_cursor"]

	total_steps = config["total_steps"] if max_steps is None else min(config["total_steps"], start_state["step"] + max_steps)
	grad_accum = config["gradient_accumulation_steps"]
	log_interval = config["log_interval_steps"]
	ckpt_interval = config["checkpoint_interval_steps"]
	ckpt_interval_sec = config["checkpoint_interval_seconds"]

	optimizer.zero_grad()
	accumulated_loss = 0.0
	last_ckpt_time = time.time()

	print(f"Starting training from step {step} to {total_steps}")
	print(f"Device: {device}, Hardware: {hw.variant}, Effective batch: {hw.effective_batch}")

	# For TPU
	is_tpu = hw.device_type == DeviceType.TPU
	if is_tpu:
	import torch_xla.core.xla_model as xm

	for epoch in range(10000): # Large number, controlled by total_steps
	for batch_idx, (input_ids, labels) in enumerate(dataloader):
	if step >= total_steps:
	break

	input_ids = input_ids.to(device, non_blocking=True)
	labels = labels.to(device, non_blocking=True)

	# Forward
	outputs = model(input_ids=input_ids, labels=labels)
	loss = outputs.loss / grad_accum

	# Backward
	loss.backward()
	accumulated_loss += loss.item()

	# Optimizer step
	if (batch_idx + 1) % grad_accum == 0:
	# Gradient clipping
	torch.nn.utils.clip_grad_norm_(model.parameters(), config["max_grad_norm"])

	if is_tpu:
	import torch_xla.core.xla_model as xm
	xm.optimizer_step(optimizer)
	else:
	optimizer.step()

	scheduler.step()
	optimizer.zero_grad()

	step += 1
	token_count += TOKENS_PER_STEP

	# Logging
	if step % log_interval == 0:
	avg_loss = accumulated_loss / log_interval
	lr = scheduler.get_last_lr()[0]
	print(f"step {step:,} \| tokens {token_count:,} \| loss {avg_loss:.4f} \| lr {lr:.2e}")
	accumulated_loss = 0.0

	# Checkpoint (step-based)
	if step % ckpt_interval == 0:
	data_cursor = {"epoch": epoch, "offset_tokens": token_count % 997_885_340}
	save_checkpoint(model, optimizer, scheduler, step, token_count,
	data_cursor, config, output_dir, hw=hw)
	last_ckpt_time = time.time()

	# Checkpoint (time-based)
	if time.time() - last_ckpt_time >= ckpt_interval_sec:
	data_cursor = {"epoch": epoch, "offset_tokens": token_count % 997_885_340}
	save_checkpoint(model, optimizer, scheduler, step, token_count,
	data_cursor, config, output_dir, hw=hw)
	last_ckpt_time = time.time()

	if step >= total_steps:
	break

	# Final checkpoint
	data_cursor = {"epoch": epoch, "offset_tokens": token_count % 997_885_340}
	save_checkpoint(model, optimizer, scheduler, step, token_count,
	data_cursor, config, output_dir, is_final=True, hw=hw)

	if is_tpu:
	import torch_xla.core.xla_model as xm
	xm.wait_device_ops()

	return step, token_count


	def setup_device(hw: HardwareInfo):
	"""Setup device for training."""
	if hw.device_type == DeviceType.CUDA:
	if hw.num_devices > 1:
	# DDP setup
	import torch.distributed as dist
	dist.init_process_group(backend="nccl")
	local_rank = int(os.environ.get("LOCAL_RANK", 0))
	device = torch.device(f"cuda:{local_rank}")
	torch.cuda.set_device(device)
	else:
	device = torch.device("cuda:0")
	# Enable TF32 for Ampere+
	if hw.supports_bf16:
	torch.backends.cuda.matmul.allow_tf32 = True
	torch.backends.cudnn.allow_tf32 = True

	elif hw.device_type == DeviceType.TPU:
	import torch_xla.core.xla_model as xm
	device = xm.xla_device()
	os.environ["PJRT_DEVICE"] = "TPU"
	os.environ["XLA_USE_BF16"] = "1"

	else:
	device = torch.device("cpu")

	return device


	def setup_optimizer(model, config):
	"""Setup optimizer and scheduler."""
	optimizer = torch.optim.AdamW(
	model.parameters(),
	lr=config["learning_rate"],
	betas=(config["adam_beta1"], config["adam_beta2"]),
	eps=config["adam_epsilon"],
	weight_decay=config["weight_decay"],
	)

	total_steps = config["total_steps"]
	warmup_steps = config["warmup_steps"]
	min_lr_ratio = config["min_lr_ratio"]

	def lr_lambda(current_step):
	if current_step < warmup_steps:
	return float(current_step + 1) / float(max(1, warmup_steps))
	progress = float(current_step - warmup_steps) / float(max(1, total_steps - warmup_steps))
	return max(min_lr_ratio, 1.0 - progress * (1.0 - min_lr_ratio))

	scheduler = torch.optim.lr_scheduler.LambdaLR(optimizer, lr_lambda)
	return optimizer, scheduler


	def main():
	parser = argparse.ArgumentParser(description="Hardware-agnostic Pear1.5 training")
	parser.add_argument("--data-path", type=Path, required=True, help="Path to expanded dataset")
	parser.add_argument("--output-dir", type=Path, required=True, help="Checkpoint output directory")
	parser.add_argument("--resume-from", type=str, default=None,
	help="Resume from checkpoint (step number, 'latest', or path)")
	parser.add_argument("--max-steps", type=int, default=None, help="Max steps to run")
	parser.add_argument("--hf-model-path", type=Path, default=None,
	help="HF model path for fresh init (if not resuming)")
	parser.add_argument("--seed", type=int, default=0)
	args = parser.parse_args()

	torch.manual_seed(args.seed)

	# Detect hardware
	hw = get_hardware_info()
	config = get_training_config(hw)

	# Setup device
	device = setup_device(hw)

	# Build or load model
	if args.resume_from:
	# Resume from checkpoint
	model = build_model(config)
	optimizer, scheduler = setup_optimizer(model, config)

	if args.resume_from == "latest":
	# Find latest checkpoint in output_dir
	ckpts = sorted(args.output_dir.glob("step_*/checkpoint.pt"))
	if not ckpts:
	raise ValueError("No checkpoints found to resume from")
	ckpt_path = ckpts[-1]
	elif args.resume_from.isdigit():
	# Step number
	step = int(args.resume_from)
	ckpt_path = args.output_dir / f"step_{step:012d}" / "checkpoint.pt"
	else:
	ckpt_path = Path(args.resume_from)

	start_state = load_checkpoint(model, optimizer, scheduler, ckpt_path, device)

	else:
	# Fresh init from HF model or scratch
	if args.hf_model_path:
	from transformers import AutoModelForCausalLM
	print(f"Loading from HF model: {args.hf_model_path}")
	model = AutoModelForCausalLM.from_pretrained(
	args.hf_model_path, torch_dtype=torch.bfloat16 if hw.supports_bf16 else torch.float32, use_cache=False
	)
	else:
	model = build_model(config)

	model.gradient_checkpointing_enable()
	model.to(device)

	optimizer, scheduler = setup_optimizer(model, config)
	start_state = {"step": 0, "token_count": 0, "data_cursor": {"epoch": 0, "offset_tokens": 0}}

	# DDP wrap for multi-GPU
	if hw.device_type == DeviceType.CUDA and hw.num_devices > 1:
	model = torch.nn.parallel.DistributedDataParallel(model, device_ids=[device.index])

	# Data loader
	dataloader = get_dataloader(args.data_path, config, device, hw)

	# Train
	final_step, final_tokens = train_loop(
	model, optimizer, scheduler, dataloader, device, config,
	start_state, args.output_dir, hw, max_steps=args.max_steps
	)

	print(f"Training complete: step {final_step}, tokens {final_tokens:,}")


	if __name__ == "__main__":
	main()