Upload folder using huggingface_hub

training/train_fsdp_full.py

@@ -0,0 +1,210 @@
+"""
+AlgoRythm Red Rock — Full Fine-Tuning Script (No LoRA)
+Target: < 2 hours on 1× H100 (80GB) or 1× A100 (80GB)
+Updates ALL 7 billion parameters.
+
+Estimate:
+  - 5,000 examples × 2048 max_len ÷ batch_eff_4 = 1,250 steps/epoch
+  - 3 epochs = 3,750 steps
+  - ~1.8 sec/step on H100 with BF16 + gradient checkpointing
+  - Total: ~1.9 hours on H100, ~1.7 hours on 2× A100
+"""
+import os
+import torch
+from datasets import load_dataset
+from transformers import (
+    AutoModelForCausalLM,
+    AutoTokenizer,
+    TrainingArguments,
+    Trainer,
+    DataCollatorForLanguageModeling,
+    EarlyStoppingCallback
+)
+
+# ============================================================
+# PATHS — Adjust if your folder structure differs
+# ============================================================
+MODEL_PATH   = "./model/qwen2.5-coder-7b-instruct-base"
+OUTPUT_DIR   = "./outputs/algorythm-prandtl-aero-7b-fft-v2"
+DATASET_PATH = "./datasets/synthetic_nozzles.json"
+
+# ============================================================
+# DETECT HARDWARE
+# ============================================================
+NUM_GPUS = torch.cuda.device_count() if torch.cuda.is_available() else 0
+GPU_NAME = torch.cuda.get_device_name(0) if NUM_GPUS > 0 else "CPU"
+GPU_MEM  = torch.cuda.get_device_properties(0).total_mem / 1e9 if NUM_GPUS > 0 else 0
+
+print(f"╔══════════════════════════════════════════════════════╗")
+print(f"║  AlgoRythm Prandtl Aero — Full Fine-Tuning (FFT)    ║")
+print(f"║  GPU: {GPU_NAME[:40]:<40s}   ║")
+print(f"║  VRAM: {GPU_MEM:.0f} GB × {NUM_GPUS} GPU(s)                            ║")
+print(f"║  Mode: FULL PARAMETER UPDATE (7B params, NO LoRA)   ║")
+print(f"╚══════════════════════════════════════════════════════╝")
+
+# ============================================================
+# HYPERPARAMETERS — Optimized for < 2hr on 1× H100/A100
+# ============================================================
+# Batch size tuning:
+#   H100 80GB BF16 + grad ckpt: batch_size=2 fits comfortably (~60GB peak)
+#   A100 80GB BF16 + grad ckpt: batch_size=2 fits (~65GB peak)
+#   A100 40GB: batch_size=1 + more grad_accum
+if GPU_MEM >= 70:
+    BATCH_SIZE = 2
+    GRAD_ACCUM = 2     # Effective batch = 4
+    MAX_LEN    = 2048
+elif GPU_MEM >= 35:
+    BATCH_SIZE = 1
+    GRAD_ACCUM = 4     # Effective batch = 4
+    MAX_LEN    = 1536
+else:
+    BATCH_SIZE = 1
+    GRAD_ACCUM = 4
+    MAX_LEN    = 1024
+
+# Use FSDP only when multi-GPU
+USE_FSDP = NUM_GPUS > 1
+
+def train():
+    print(f"\n[1/5] Loading tokenizer from {MODEL_PATH}...")
+    tokenizer = AutoTokenizer.from_pretrained(MODEL_PATH, trust_remote_code=True)
+    if tokenizer.pad_token is None:
+        tokenizer.pad_token = tokenizer.eos_token
+
+    print(f"[2/5] Loading 7B model in BF16 (full precision, NO quantization)...")
+    model = AutoModelForCausalLM.from_pretrained(
+        MODEL_PATH,
+        torch_dtype=torch.bfloat16,
+        trust_remote_code=True,
+        use_cache=False,              # Must disable for gradient checkpointing
+        attn_implementation="eager",  # Safest for training
+    )
+
+    # Enable gradient checkpointing (trades compute for VRAM)
+    model.gradient_checkpointing_enable()
+
+    # Verify: ALL parameters are trainable (no frozen layers)
+    total_params = sum(p.numel() for p in model.parameters())
+    train_params = sum(p.numel() for p in model.parameters() if p.requires_grad)
+    print(f"    Total parameters:     {total_params:,}")
+    print(f"    Trainable parameters: {train_params:,}")
+    assert train_params == total_params, "ERROR: Some parameters are frozen! This is FULL fine-tuning."
+    print(f"    ✓ Confirmed: 100% of parameters will be updated (FULL FFT)")
+
+    print(f"\n[3/5] Loading dataset from {DATASET_PATH}...")
+    dataset = load_dataset("json", data_files=DATASET_PATH, split="train")
+    print(f"    Loaded {len(dataset)} examples")
+
+    # Tokenize using Qwen2.5 ChatML format
+    def tokenize_fn(examples):
+        texts = []
+        for i in range(len(examples["input"])):
+            inp = examples["input"][i]
+            reasoning = examples["reasoning"][i]
+            output = examples["output"][i]
+
+            # ChatML format (Qwen2.5 native)
+            text = (
+                f"<|im_start|>system\n"
+                f"You are AlgoRythm Red Rock, a deterministic computational engineering model. "
+                f"You solve rocket engine design problems using first-principles physics. "
+                f"All dimensions are in mm (PicoGK convention). "
+                f"You must show complete derivations before generating code.\n"
+                f"<|im_end|>\n"
+                f"<|im_start|>user\n{inp}\n<|im_end|>\n"
+                f"<|im_start|>assistant\n{reasoning}\n\n{output}<|im_end|>"
+            )
+            texts.append(text)
+
+        tokenized = tokenizer(
+            texts,
+            truncation=True,
+            max_length=MAX_LEN,
+            padding="max_length",
+            return_tensors="pt"
+        )
+        tokenized["labels"] = tokenized["input_ids"].clone()
+        return tokenized
+
+    print(f"    Tokenizing (max_length={MAX_LEN})...")
+    tokenized = dataset.map(tokenize_fn, batched=True, batch_size=100,
+                            remove_columns=dataset.column_names)
+
+    # Split: 95% train, 5% eval
+    split = tokenized.train_test_split(test_size=0.05, seed=42)
+    train_ds = split["train"]
+    eval_ds  = split["test"]
+    print(f"    Train: {len(train_ds)} | Eval: {len(eval_ds)}")
+
+    # Training time estimate
+    steps_per_epoch = len(train_ds) // (BATCH_SIZE * GRAD_ACCUM * max(NUM_GPUS, 1))
+    total_steps = steps_per_epoch * 3
+    est_time_min = total_steps * 1.8 / 60  # ~1.8s/step on H100
+    print(f"\n[4/5] Training configuration:")
+    print(f"    Batch size: {BATCH_SIZE} × grad_accum {GRAD_ACCUM} = effective {BATCH_SIZE * GRAD_ACCUM}")
+    print(f"    Steps/epoch: ~{steps_per_epoch} | Total steps: ~{total_steps}")
+    print(f"    Estimated time: ~{est_time_min:.0f} minutes ({est_time_min/60:.1f} hours)")
+
+    # Build TrainingArguments
+    training_args_dict = {
+        "output_dir": OUTPUT_DIR,
+        "num_train_epochs": 3,
+        "per_device_train_batch_size": BATCH_SIZE,
+        "gradient_accumulation_steps": GRAD_ACCUM,
+        "learning_rate": 2e-5,            # Standard for full fine-tuning
+        "lr_scheduler_type": "cosine",    # Smooth decay
+        "weight_decay": 0.01,
+        "warmup_ratio": 0.05,
+        "max_grad_norm": 1.0,
+        "bf16": True,
+        "tf32": True,
+        "gradient_checkpointing": True,
+        "logging_steps": 25,
+        "evaluation_strategy": "steps",
+        "eval_steps": 200,
+        "save_strategy": "steps",
+        "save_steps": 500,
+        "save_total_limit": 3,
+        "load_best_model_at_end": True,
+        "metric_for_best_model": "eval_loss",
+        "greater_is_better": False,
+        "dataloader_num_workers": 4,
+        "dataloader_pin_memory": True,
+        "report_to": "none",              # Set to "wandb" if you have W&B
+        "remove_unused_columns": False,
+    }
+
+    # Add FSDP config only for multi-GPU
+    if USE_FSDP:
+        training_args_dict["fsdp"] = "full_shard auto_wrap"
+        training_args_dict["fsdp_transformer_layer_cls_to_wrap"] = "Qwen2DecoderLayer"
+        print(f"    FSDP: ENABLED (sharding across {NUM_GPUS} GPUs)")
+    else:
+        print(f"    FSDP: DISABLED (single GPU mode)")
+
+    training_args = TrainingArguments(**training_args_dict)
+
+    trainer = Trainer(
+        model=model,
+        args=training_args,
+        train_dataset=train_ds,
+        eval_dataset=eval_ds,
+        data_collator=DataCollatorForLanguageModeling(tokenizer, mlm=False),
+        callbacks=[EarlyStoppingCallback(early_stopping_patience=5)]
+    )
+
+    print(f"\n[5/5] 🔥 LAUNCHING FULL FINE-TUNING (updating ALL {total_params:,} parameters)...")
+    print(f"       Target: < 2 hours")
+    print(f"       Loss should decrease: ~2.5 → ~0.5")
+    print(f"=" * 55)
+
+    trainer.train()
+
+    # Save final model
+    print(f"\n✅ Training complete! Saving to {OUTPUT_DIR}...")
+    trainer.save_model(OUTPUT_DIR)
+    tokenizer.save_pretrained(OUTPUT_DIR)
+    print(f"✅ Model saved. Ready for inference.")
+
+if __name__ == "__main__":
+    train()

training/train_full.py

@@ -0,0 +1,204 @@
+"""
+AlgoRythm Red Rock - FULL FINE-TUNING Script (Single A100/H100 Optimized)
+Transforms Qwen2.5-Coder-7B into a Deterministic CEM (Physics-Native)
+Training time: ~1.5h on Single H100 (using Paged AdamW 8-bit)
+"""
+
+import os
+import json
+import torch
+from datasets import Dataset
+from transformers import (
+    AutoModelForCausalLM,
+    AutoTokenizer,
+    TrainingArguments,
+    Trainer,
+    DataCollatorForLanguageModeling,
+    EarlyStoppingCallback
+)
+
+# Configuration
+MODEL_NAME = "Qwen/Qwen2.5-Coder-7B-Instruct"
+OUTPUT_DIR = "./model/algorythm-prandtl-aero-7b-full-h100"
+DATASET_DIR = "./datasets"
+
+# Training Hyperparameters for SINGLE H100 FULL FINE-TUNING
+# The "Secret Sauce": Paged AdamW 8-bit + BFloat16 + Gradient Checkpointing
+TRAINING_CONFIG = {
+    "num_train_epochs": 2, # Optimized for 2.3hr limit with High-Density Data
+    "per_device_train_batch_size": 1,   # Tiny batch size to fit in VRAM
+    "gradient_accumulation_steps": 32,  # Large accumulation to simulate Batch Size ~32-64
+    "learning_rate": 1e-5,              # Conservative LR for stability
+    "warmup_ratio": 0.05,
+    "weight_decay": 0.05,
+    "max_grad_norm": 0.3,
+    "bf16": True,                       # Mandatory for H100 speed
+    "gradient_checkpointing": True,     # Mandatory to save Activation Memory
+    "optim": "paged_adamw_8bit",        # THE KEY: Offloads optimizer state to CPU RAM
+    
+    "logging_steps": 5,
+    "save_strategy": "steps",
+    "save_steps": 50,
+    "evaluation_strategy": "steps",
+    "eval_steps": 50,
+    "load_best_model_at_end": True,
+    "max_seq_length": 4096,
+}
+
+SYSTEM_PROMPT = """You are AlgoRythm Prandtl Aero, a deterministic Computational Engineering Model.
+You generate ONLY physically valid designs using PicoGK.
+
+RESPONSE FORMAT:
+[REQUIREMENTS_PARSE] - Extract requirements
+[PHYSICS_DERIVATION] - Step-by-step math with LaTeX (Von Mises, Bartz, Navier-Stokes)
+[CONSTRAINT_VALIDATION] - Check physical limits (Yield, Overhangs, Thermal)
+[PICOGK_CODE] - Generate executable C# code
+
+NEVER guess constants. ALWAYS show derivations. ALWAYS validate."""
+
+def load_datasets():
+    """Load all JSON datasets from the datasets directory"""
+    all_examples = []
+    for filename in os.listdir(DATASET_DIR):
+        if filename.endswith('.json'):
+            filepath = os.path.join(DATASET_DIR, filename)
+            with open(filepath, 'r') as f:
+                data = json.load(f)
+                all_examples.extend(data)
+    print(f"Loaded {len(all_examples)} training examples")
+    return all_examples
+
+def format_for_training(examples, tokenizer):
+    """Format examples into training format"""
+    formatted = []
+    for ex in examples:
+        instruction = f"""<|im_start|>system
+{SYSTEM_PROMPT}<|im_end|>
+<|im_start|>user
+{ex['input']}<|im_end|>
+<|im_start|>assistant
+{ex['reasoning']}
+
+[PICOGK_CODE]
+```csharp
+{ex['output']}
+```<|im_end|>"""
+        formatted.append({"text": instruction})
+    return Dataset.from_list(formatted)
+
+def main():
+    print("="*60)
+    print("ALGORYTHM PRANDTL AERO - SINGLE H100 FULL FINE-TUNING")
+    print("Optimization: Paged AdamW 8-bit + Gradient Checkpointing")
+    print("="*60)
+    
+    # Load tokenizer
+    print("\n[1/4] Loading tokenizer...")
+    tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME, trust_remote_code=True)
+    tokenizer.pad_token = tokenizer.eos_token
+    
+    # Load Base Model (Full Precision Weights,cast to BF16 on fly)
+    print("\n[2/4] Loading base model...")
+    
+    # --- SAFETY CHECK: PRE-FLIGHT ENVIRONMENT AUDIT ---
+    print("\n   >>> RUNNING PRE-FLIGHT SAFETY CHECKS (User Order: No Financial Waste) <<<")
+    # 1. CUDA Check
+    if not torch.cuda.is_available():
+        raise RuntimeError("FATAL: No GPU detected! Aborting to save money.")
+    print("   [PASS] GPU Detected: " + torch.cuda.get_device_name(0))
+    
+    # 2. BF16 Check (Required for H100 Optimization)
+    if not torch.cuda.is_bf16_supported():
+         print("   [WARNING] BF16 not supported on this GPU. Falling back to FP16 (Slower).")
+         TRAINING_CONFIG["bf16"] = False
+         TRAINING_CONFIG["fp16"] = True
+    else:
+         print("   [PASS] BF16 Operations Supported.")
+
+    # 3. RAM Check (Prevent OOM crash after 10 mins)
+    import psutil
+    mem = psutil.virtual_memory()
+    if mem.total < 30 * 1024**3: # Check for at least 30GB System RAM for offloading
+        print(f"   [WARNING] System RAM is low ({mem.total/1024**3:.1f} GB). Paged Optimizer might swap heavily.")
+    else:
+        print(f"   [PASS] System RAM: {mem.total/1024**3:.1f} GB (Healthy for Offloading).")
+        
+    model = AutoModelForCausalLM.from_pretrained(
+        MODEL_NAME,
+        torch_dtype=torch.bfloat16 if TRAINING_CONFIG.get("bf16", True) else torch.float16,
+        trust_remote_code=True,
+        use_cache=False,
+    )
+    
+    # Enable Gradient Checkpointing (Crucial for VRAM)
+    model.gradient_checkpointing_enable()
+    
+    # Load and format dataset
+    print("\n[3/4] Loading datasets...")
+    examples = load_datasets()
+    if not examples:
+        raise ValueError("FATAL: Dataset is empty! check ./datasets folder.")
+        
+    # --- SAFETY CHECK: DATA INTEGRITY ---
+    print(f"   [PASS] Loaded {len(examples)} examples.")
+    print("   [AUDIT] Inspecting First Training Sample for Corruption:")
+    print("-" * 40)
+    print(f"INPUT PREVIEW:\n{examples[0]['input'][:200]}...")
+    print(f"OUTPUT PREVIEW:\n{examples[0]['output'][:200]}...")
+    print("-" * 40)
+    
+    dataset = format_for_training(examples, tokenizer)
+    
+    # Tokenize
+    def tokenize(examples):
+        return tokenizer(
+            examples["text"],
+            truncation=True,
+            max_length=TRAINING_CONFIG["max_seq_length"],
+            padding="max_length"
+        )
+    tokenized_dataset = dataset.map(tokenize, batched=True)
+    
+    # Training arguments
+    print("\n[4/4] Setting up Paged 8-bit Optimizer...")
+    training_args = TrainingArguments(
+        output_dir=OUTPUT_DIR,
+        num_train_epochs=TRAINING_CONFIG["num_train_epochs"],
+        per_device_train_batch_size=TRAINING_CONFIG["per_device_train_batch_size"],
+        gradient_accumulation_steps=TRAINING_CONFIG["gradient_accumulation_steps"],
+        learning_rate=TRAINING_CONFIG["learning_rate"],
+        warmup_ratio=TRAINING_CONFIG["warmup_ratio"],
+        weight_decay=TRAINING_CONFIG["weight_decay"],
+        bf16=TRAINING_CONFIG["bf16"],
+        logging_steps=TRAINING_CONFIG["logging_steps"],
+        save_strategy=TRAINING_CONFIG["save_strategy"],
+        optim=TRAINING_CONFIG["optim"], # paged_adamw_8bit
+        report_to="none"
+    )
+    
+    data_collator = DataCollatorForLanguageModeling(tokenizer=tokenizer, mlm=False)
+    
+    trainer = Trainer(
+        model=model,
+        args=training_args,
+        train_dataset=tokenized_dataset,
+        eval_dataset=tokenized_dataset.select(range(min(50, len(tokenized_dataset)))),
+        data_collator=data_collator,
+        callbacks=[EarlyStoppingCallback(early_stopping_patience=3)]
+    )
+    
+    print("\nStarting FULL FINE-TUNING on Single H100...")
+    print("Strategy: CPU Offloading of Optimizer States to save VRAM.")
+    trainer.train()
+    
+    print("\nSaving full model...")
+    trainer.save_model(OUTPUT_DIR)
+    tokenizer.save_pretrained(OUTPUT_DIR)
+    
+    print("\n" + "="*60)
+    print("FULL FINE-TUNING COMPLETE!")
+    print(f"Model saved to: {OUTPUT_DIR}")
+    print("="*60)
+
+if __name__ == "__main__":
+    main()