"""Hardware detection and optimal configuration for Pear1.5 training. Auto-detects: CUDA GPU (type, VRAM), TPU (type, cores), CPU. Returns optimal training config for the detected hardware. """ import os import json import torch from dataclasses import dataclass, asdict from typing import Optional, Dict, Any from enum import Enum class DeviceType(Enum): CUDA = "cuda" TPU = "tpu" CPU = "cpu" class GPUVariant(Enum): A100_40GB = "A100-40GB" A100_80GB = "A100-80GB" H100_80GB = "H100-80GB" V100_32GB = "V100-32GB" V100_16GB = "V100-16GB" T4_16GB = "T4-16GB" P100_16GB = "P100-16GB" RTX_5060_TI_16GB = "RTX-5060-TI-16GB" RTX_4090_24GB = "RTX-4090-24GB" RTX_3090_24GB = "RTX-3090-24GB" UNKNOWN = "UNKNOWN" class TPUVariant(Enum): V3_8 = "v3-8" V3_32 = "v3-32" V4_8 = "v4-8" V4_16 = "v4-16" V5E_8 = "v5e-8" V5E_16 = "v5e-16" V5E_32 = "v5e-32" V5P_8 = "v5p-8" UNKNOWN = "UNKNOWN" @dataclass class HardwareInfo: device_type: DeviceType variant: str num_devices: int vram_per_device_gb: int total_vram_gb: int supports_bf16: bool supports_fp8: bool max_batch_per_device: int # at seq_len=1024, model=134M recommended_grad_accum: int effective_batch: int notes: str # Model constants MODEL_PARAMS = 134_500_000 # 134.5M SEQ_LEN = 1024 HIDDEN = 576 LAYERS = 30 HEADS = 9 KV_HEADS = 3 VOCAB = 49152 # Rough VRAM per param (bf16): 2 bytes + optimizer states (8 bytes AdamW) = ~10 bytes/param # + activations ~ batch * seq * hidden * layers * 2 bytes # For batch=1: ~1.3GB model+optim, ~0.3GB activations = ~1.6GB base def detect_cuda() -> Optional[HardwareInfo]: """Detect NVIDIA GPU and return optimal config.""" if not torch.cuda.is_available(): return None name = torch.cuda.get_device_name(0).upper() props = torch.cuda.get_device_properties(0) vram_gb = props.total_memory // (1024**3) num_gpus = torch.cuda.device_count() # Identify variant variant = GPUVariant.UNKNOWN if "A100" in name and "80" in name: variant = GPUVariant.A100_80GB elif "A100" in name: variant = GPUVariant.A100_40GB elif "H100" in name: variant = GPUVariant.H100_80GB elif "V100" in name and "32" in name: variant = GPUVariant.V100_32GB elif "V100" in name: variant = GPUVariant.V100_16GB elif "T4" in name: variant = GPUVariant.T4_16GB elif "P100" in name: variant = GPUVariant.P100_16GB elif "RTX 5060 TI" in name or "5060 TI" in name: variant = GPUVariant.RTX_5060_TI_16GB elif "RTX 4090" in name: variant = GPUVariant.RTX_4090_24GB elif "RTX 3090" in name: variant = GPUVariant.RTX_3090_24GB # Optimal batch sizes per device (seq=1024, bf16, gradient_checkpointing=True) batch_map = { GPUVariant.A100_80GB: 64, GPUVariant.A100_40GB: 32, GPUVariant.H100_80GB: 64, GPUVariant.V100_32GB: 16, GPUVariant.V100_16GB: 8, GPUVariant.T4_16GB: 4, GPUVariant.P100_16GB: 4, GPUVariant.RTX_5060_TI_16GB: 4, GPUVariant.RTX_4090_24GB: 8, GPUVariant.RTX_3090_24GB: 8, GPUVariant.UNKNOWN: 2, } max_batch = batch_map.get(variant, 2) # Target effective batch = 16 (matches original A100 run) target_effective = 16 grad_accum = max(1, target_effective // (max_batch * num_gpus)) effective = max_batch * num_gpus * grad_accum return HardwareInfo( device_type=DeviceType.CUDA, variant=variant.value, num_devices=num_gpus, vram_per_device_gb=vram_gb, total_vram_gb=vram_gb * num_gpus, supports_bf16=props.major >= 8, # Ampere+ supports_fp8="H100" in name, max_batch_per_device=max_batch, recommended_grad_accum=grad_accum, effective_batch=effective, notes=f"Detected {num_gpus}x {variant.value} ({vram_gb}GB each). Target effective batch: {target_effective}" ) def detect_tpu() -> Optional[HardwareInfo]: """Detect TPU and return optimal config.""" # Check for TPU via environment (Kaggle, Colab, GCP) tpu_name = os.environ.get("TPU_NAME", "").lower() if not tpu_name: # Try XLA try: import torch_xla.core.xla_model as xm devices = xm.get_xla_supported_devices() if devices: tpu_name = str(devices[0]).lower() except Exception: pass if not tpu_name: # Check Kaggle/Colab TPU env vars if os.environ.get("COLAB_TPU_ADDR") or os.environ.get("TPU_ADDR"): tpu_name = "v5e-8" # Default assumption for Kaggle/Colab if not tpu_name: return None # Identify variant variant = TPUVariant.UNKNOWN for v in TPUVariant: if v.value in tpu_name: variant = v break # TPU specs tpu_specs = { TPUVariant.V3_8: {"cores": 8, "hbm_per_core_gb": 16}, TPUVariant.V3_32: {"cores": 32, "hbm_per_core_gb": 16}, TPUVariant.V4_8: {"cores": 8, "hbm_per_core_gb": 32}, TPUVariant.V4_16: {"cores": 16, "hbm_per_core_gb": 32}, TPUVariant.V5E_8: {"cores": 8, "hbm_per_core_gb": 16}, TPUVariant.V5E_16: {"cores": 16, "hbm_per_core_gb": 16}, TPUVariant.V5E_32: {"cores": 32, "hbm_per_core_gb": 16}, TPUVariant.V5P_8: {"cores": 8, "hbm_per_core_gb": 96}, } specs = tpu_specs.get(variant, {"cores": 8, "hbm_per_core_gb": 16}) num_cores = specs["cores"] hbm_per_core = specs["hbm_per_core_gb"] # Batch size per core (seq=1024, bf16, gradient_checkpointing) batch_per_core_map = { TPUVariant.V3_8: 2, TPUVariant.V3_32: 2, TPUVariant.V4_8: 4, TPUVariant.V4_16: 4, TPUVariant.V5E_8: 2, TPUVariant.V5E_16: 2, TPUVariant.V5E_32: 2, TPUVariant.V5P_8: 8, TPUVariant.UNKNOWN: 1, } max_batch = batch_per_core_map.get(variant, 1) target_effective = 16 grad_accum = max(1, target_effective // (max_batch * num_cores)) effective = max_batch * num_cores * grad_accum return HardwareInfo( device_type=DeviceType.TPU, variant=variant.value, num_devices=num_cores, vram_per_device_gb=hbm_per_core, total_vram_gb=hbm_per_core * num_cores, supports_bf16=True, supports_fp8=False, max_batch_per_device=max_batch, recommended_grad_accum=grad_accum, effective_batch=effective, notes=f"Detected TPU {variant.value} ({num_cores} cores, {hbm_per_core}GB HBM/core)" ) def detect_cpu() -> HardwareInfo: """Fallback CPU config.""" import multiprocessing return HardwareInfo( device_type=DeviceType.CPU, variant="CPU", num_devices=1, vram_per_device_gb=0, total_vram_gb=0, supports_bf16=False, supports_fp8=False, max_batch_per_device=1, recommended_grad_accum=16, effective_batch=16, notes=f"CPU fallback ({multiprocessing.cpu_count()} cores). Very slow." ) def get_hardware_info() -> HardwareInfo: """Auto-detect best available hardware.""" # Priority: CUDA > TPU > CPU for detector in [detect_cuda, detect_tpu]: hw = detector() if hw: return hw return detect_cpu() def get_training_config(hw: HardwareInfo) -> Dict[str, Any]: """Generate complete training config for the detected hardware.""" base_config = { # Model "model_type": "llama", "vocab_size": VOCAB, "hidden_size": HIDDEN, "num_hidden_layers": LAYERS, "num_attention_heads": HEADS, "num_key_value_heads": KV_HEADS, "tie_word_embeddings": True, "max_position_embeddings": 2048, "rope_theta": 10000.0, # Training "sequence_length": SEQ_LEN, "batch_size": hw.max_batch_per_device, "gradient_accumulation_steps": hw.recommended_grad_accum, "gradient_checkpointing": True, "loss_chunk_tokens": 8192, "precision": "bf16" if hw.supports_bf16 else "fp32", "learning_rate": 3e-4, "min_lr_ratio": 0.1, "weight_decay": 0.1, "adam_beta1": 0.9, "adam_beta2": 0.95, "adam_epsilon": 1e-8, "max_grad_norm": 1.0, "warmup_steps": 500, "total_steps": 2_929_688, # (50B - 1.74B) / 16384 "checkpoint_interval_steps": 500, "checkpoint_interval_seconds": 1800, "log_interval_steps": 50, "eval_interval_steps": 2000, "eval_targets": 8192, "seed": 0, # Hardware-specific "device_type": hw.device_type.value, "num_devices": hw.num_devices, "effective_batch": hw.effective_batch, "hardware_variant": hw.variant, } # TPU-specific additions if hw.device_type == DeviceType.TPU: base_config.update({ "xla_device": "TPU", "pjrt_device": "TPU", "use_spmd": hw.num_devices > 8, }) # CUDA-specific additions if hw.device_type == DeviceType.CUDA: base_config.update({ "cuda_device": "cuda", "use_ddp": hw.num_devices > 1, "nccl_backend": "nccl", }) return base_config def print_hardware_summary(hw: HardwareInfo, config: Dict): """Pretty print hardware detection and config.""" print("=" * 60) print(f"HARDWARE DETECTED: {hw.device_type.value.upper()} - {hw.variant}") print("=" * 60) print(f"Devices: {hw.num_devices} x {hw.variant}") print(f"VRAM/HBM per device: {hw.vram_per_device_gb} GB") print(f"Total VRAM/HBM: {hw.total_vram_gb} GB") print(f"BF16 support: {hw.supports_bf16}") print(f"FP8 support: {hw.supports_fp8}") print(f"Max batch/device: {hw.max_batch_per_device}") print(f"Grad accum steps: {hw.recommended_grad_accum}") print(f"Effective batch: {hw.effective_batch} (target: 16)") print(f"Precision: {config['precision']}") print(f"Notes: {hw.notes}") print("=" * 60) if __name__ == "__main__": hw = get_hardware_info() config = get_training_config(hw) print_hardware_summary(hw, config) print(json.dumps(config, indent=2))