#!/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()