Add post-training merge + benchmark script

scripts/sakthai-7b-post-train.py

@@ -0,0 +1,337 @@
+#!/usr/bin/env python3
+"""
+SakThai 7B Post-Training Pipeline
+=================================
+Run AFTER Kaggle notebook finishes training.
+
+Steps:
+1. Download LoRA adapter from HF
+2. Merge with base Qwen2.5-7B-Instruct
+3. Push merged safetensors to HF
+4. Quantize to GGUF Q4_K_M
+5. Run BFCL-style benchmark
+6. Generate final report
+
+Usage:
+    # HF_TOKEN must be set or passed via env
+    python3 sakthai-7b-post-train.py
+
+Requires:
+    pip install transformers peft accelerate torch huggingface_hub
+    # For GGUF quant: llama.cpp built with llama-quantize
+"""
+
+import os
+import json
+import sys
+import datetime
+import torch
+from huggingface_hub import login, HfApi, snapshot_download
+from transformers import AutoModelForCausalLM, AutoTokenizer
+from peft import PeftModel
+
+# ─── Config ─────────────────────────────────────────────────
+BASE_MODEL = "Qwen/Qwen2.5-7B-Instruct"
+ADAPTER_REPO = "Nanthasit/sakthai-7b-lora-kaggle"
+MERGED_REPO = "Nanthasit/sakthai-context-7b-tools"
+HF_TOKEN = os.environ.get("HF_TOKEN")
+WORK_DIR = "/opt/data/sakthai-7b-post"
+os.makedirs(WORK_DIR, exist_ok=True)
+
+REPORT = {
+    "pipeline": "sakthai-7b-post-train",
+    "start_time": str(datetime.datetime.now()),
+    "steps": {},
+}
+
+# ─── Auth ────────────────────────────────────────────────────
+if HF_TOKEN:
+    login(token=HF_TOKEN, add_to_git_credential=True)
+    api = HfApi()
+    user = api.whoami()["name"]
+    print(f"✅ Authenticated as: {user}")
+else:
+    print("❌ HF_TOKEN not set")
+    sys.exit(1)
+
+device = "cuda" if torch.cuda.is_available() else "cpu"
+print(f"Using device: {device}")
+
+# ═════════════════════════════════════════════════════════════
+# Step 1: Download adapter
+# ═════════════════════════════════════════════════════════════
+print("\n" + "="*60)
+print("📥 Step 1: Downloading LoRA adapter")
+print("="*60)
+adapter_path = f"{WORK_DIR}/adapter"
+snapshot_download(
+    repo_id=ADAPTER_REPO,
+    local_dir=adapter_path,
+    repo_type="model",
+)
+print(f"✅ Adapter downloaded to {adapter_path}")
+
+# ═════════════════════════════════════════════════════════════
+# Step 2: Merge with base model
+# ═════════════════════════════════════════════════════════════
+print("\n" + "="*60)
+print("🔗 Step 2: Merging LoRA with base model")
+print("="*60)
+merge_path = f"{WORK_DIR}/merged"
+os.makedirs(merge_path, exist_ok=True)
+
+try:
+    tokenizer = AutoTokenizer.from_pretrained(BASE_MODEL, trust_remote_code=True)
+    
+    if device == "cuda":
+        base = AutoModelForCausalLM.from_pretrained(
+            BASE_MODEL, torch_dtype=torch.bfloat16, device_map="auto", trust_remote_code=True
+        )
+        merged = PeftModel.from_pretrained(base, adapter_path)
+        merged_model = merged.merge_and_unload()
+    else:
+        # CPU merge — slower but works
+        print("CPU merge — this will take a while for 7B...")
+        base = AutoModelForCausalLM.from_pretrained(
+            BASE_MODEL, torch_dtype=torch.float32, device_map="cpu", trust_remote_code=True
+        )
+        merged = PeftModel.from_pretrained(base, adapter_path)
+        merged_model = merged.merge_and_unload()
+    
+    merged_model.save_pretrained(merge_path, safe_serialization=True)
+    tokenizer.save_pretrained(merge_path)
+    print(f"✅ Merged model saved to {merge_path}")
+    REPORT["steps"]["merge"] = {"status": "success", "path": merge_path}
+except Exception as e:
+    print(f"❌ Merge failed: {e}")
+    REPORT["steps"]["merge"] = {"status": "failed", "error": str(e)}
+    sys.exit(1)
+
+# ═════════════════════════════════════════════════════════════
+# Step 3: Push merged model to HF
+# ═════════════════════════════════════════════════════════════
+print("\n" + "="*60)
+print("☁️ Step 3: Pushing merged model to HF Hub")
+print("="*60)
+try:
+    api.create_repo(repo_id=MERGED_REPO, repo_type="model", exist_ok=True, private=False)
+    api.upload_folder(
+        folder_path=merge_path,
+        repo_id=MERGED_REPO,
+        path_in_repo=".",
+        commit_message="Merge Qwen2.5-7B-Instruct + sakthai-v5 LoRA",
+    )
+    url = f"https://huggingface.co/{MERGED_REPO}"
+    print(f"✅ Merged model pushed: {url}")
+    REPORT["steps"]["push_merged"] = {"status": "success", "url": url}
+except Exception as e:
+    print(f"❌ Push failed: {e}")
+    REPORT["steps"]["push_merged"] = {"status": "failed", "error": str(e)}
+
+# ═════════════════════════════════════════════════════════════
+# Step 4: GGUF Quantization (if llama.cpp is available)
+# ═════════════════════════════════════════════════════════════
+print("\n" + "="*60)
+print("🔧 Step 4: GGUF Quantization")
+print("="*60)
+quant_path = f"{WORK_DIR}/gguf"
+os.makedirs(quant_path, exist_ok=True)
+
+# Check if llama-quantize is available
+import shutil
+llama_quantize = shutil.which("llama-quantize")
+
+if llama_quantize:
+    print(f"Found llama-quantize at: {llama_quantize}")
+    f16_path = f"{quant_path}/sakthai-7b-tools-f16.gguf"
+    q4_path = f"{quant_path}/sakthai-7b-tools-Q4_K_M.gguf"
+    
+    # Convert to FP16 GGUF first
+    convert_script = shutil.which("convert_hf_to_gguf.py") or "/tmp/llama.cpp/convert_hf_to_gguf.py"
+    if os.path.exists(convert_script):
+        import subprocess
+        subprocess.run([
+            sys.executable, convert_script, merge_path,
+            "--outfile", f16_path, "--outtype", "f16"
+        ], check=True)
+        print(f"✅ FP16 GGUF: {f16_path}")
+        
+        # Quantize to Q4_K_M
+        subprocess.run([
+            llama_quantize, f16_path, q4_path, "Q4_K_M"
+        ], check=True)
+        print(f"✅ Q4_K_M GGUF: {q4_path}")
+        
+        # Upload GGUF to HF
+        api.upload_file(
+            path_or_fileobj=q4_path,
+            path_in_repo="gguf/sakthai-7b-tools-Q4_K_M.gguf",
+            repo_id=MERGED_REPO,
+            repo_type="model",
+            commit_message="Add Q4_K_M GGUF quant for Ollama/llama.cpp",
+        )
+        print(f"✅ GGUF uploaded to HF")
+        REPORT["steps"]["gguf"] = {"status": "success", "path": q4_path}
+    else:
+        print("⚠️ convert_hf_to_gguf.py not found, skipping GGUF")
+        REPORT["steps"]["gguf"] = {"status": "skipped", "reason": "convert script not found"}
+else:
+    print("⚠️ llama-quantize not found, skipping GGUF")
+    REPORT["steps"]["gguf"] = {"status": "skipped", "reason": "llama-quantize not found"}
+
+# ═════════════════════════════════════════════════════════════
+# Step 5: BFCL-Style Benchmark
+# ═════════════════════════════════════════════════════════════
+print("\n" + "="*60)
+print("📊 Step 5: BFCL-Style Benchmark")
+print("="*60)
+
+BFCL_TESTS = [
+    # simple category
+    {"name": "simple/get_weather", "category": "simple",
+     "system": "You have access to get_weather(city: str) -> str. Use it when the user asks about weather.",
+     "prompt": "What's the weather in Paris?",
+     "expected_tool": "get_weather"},
+    {"name": "simple/search_web", "category": "simple",
+     "system": "You have access to search_web(query: str) -> list. Use it to answer questions needing current info.",
+     "prompt": "Search for latest news about AI",
+     "expected_tool": "search_web"},
+    # multiple (parallel)
+    {"name": "multiple/dual_weather", "category": "multiple",
+     "system": "You have access to get_weather(city: str) -> str. You can call multiple functions in parallel.",
+     "prompt": "Weather in Tokyo, London, and New York?",
+     "expects_parallel": True},
+    # irrelevance
+    {"name": "irrelevance/literature", "category": "irrelevance",
+     "system": "You have access to get_weather(city: str) -> str. Only call functions when the user asks for weather.",
+     "prompt": "Who wrote Romeo and Juliet?",
+     "expects_no_tool": True},
+    # simple_python
+    {"name": "simple_python/calculate", "category": "simple_python",
+     "system": "You have access to python_repl(code: str) -> str. Use it to run Python code for calculations.",
+     "prompt": "Calculate the factorial of 10",
+     "expected_tool": "python_repl"},
+]
+
+benchmark_results = []
+for test in BFCL_TESTS:
+    print(f"\n{'─'*40}")
+    print(f"Testing: {test['name']}")
+    
+    msgs = [
+        {"role": "system", "content": test["system"]},
+        {"role": "user", "content": test["prompt"]},
+    ]
+    inputs = tokenizer.apply_chat_template(msgs, return_tensors="pt", add_generation_prompt=True)
+    inputs = inputs.to(merged_model.device if hasattr(merged_model, 'device') else "cpu")
+    
+    with torch.no_grad():
+        outputs = merged_model.generate(
+            inputs,
+            max_new_tokens=256,
+            do_sample=False,
+            temperature=0.1,
+            pad_token_id=tokenizer.eos_token_id,
+        )
+    
+    response = tokenizer.decode(outputs[0][inputs.shape[1]:], skip_special_tokens=False)
+    print(f"Response: {response[:200]}")
+    
+    # Evaluate
+    result = {
+        "test": test["name"],
+        "category": test["category"],
+        "system": test["system"],
+        "prompt": test["prompt"],
+        "response_preview": response[:200],
+    }
+    
+    # Check for expected tool
+    if test.get("expected_tool"):
+        result["expected_tool"] = test["expected_tool"]
+        result["detected_tool"] = test["expected_tool"] in response
+        result["passed"] = result["detected_tool"]
+    elif test.get("expects_no_tool"):
+        has_tool = any(t in response for t in ["get_weather(", "search_web(", "python_repl("])
+        result["expected_no_tool"] = True
+        result["detected_tool"] = not has_tool
+        result["passed"] = not has_tool
+    elif test.get("expects_parallel"):
+        # Check if multiple tool calls are present
+        count = response.count("get_weather(")
+        result["expected_parallel"] = True
+        result["detected_calls"] = count
+        result["passed"] = count >= 2
+    
+    print(f"{'✅ PASS' if result['passed'] else '❌ FAIL'}")
+    benchmark_results.append(result)
+
+REPORT["steps"]["benchmark"] = {
+    "status": "completed",
+    "results": benchmark_results,
+}
+passed = sum(1 for r in benchmark_results if r["passed"])
+total = len(benchmark_results)
+print(f"\n📊 Benchmark: {passed}/{total} passed")
+
+# ═════════════════════════════════════════════════════════════
+# Step 6: Save final report
+# ═════════════════════════════════════════════════════════════
+print("\n" + "="*60)
+print("📄 Step 6: Saving final report")
+print("="*60)
+
+REPORT["end_time"] = str(datetime.datetime.now())
+REPORT["summary"] = {
+    "merge_success": REPORT["steps"]["merge"]["status"] == "success",
+    "gguf_created": REPORT["steps"]["gguf"]["status"] == "success",
+    "benchmark_passed": f"{passed}/{total}",
+}
+
+report_path = f"{WORK_DIR}/final-report.json"
+with open(report_path, "w") as f:
+    json.dump(REPORT, f, indent=2, default=str)
+print(f"📄 Report: {report_path}")
+
+# Push report
+api.upload_file(
+    path_or_fileobj=report_path,
+    path_in_repo="results/final-report.json",
+    repo_id=MERGED_REPO,
+    repo_type="model",
+    commit_message="Final post-training report with merge + benchmark results",
+)
+try:
+    api.upload_file(
+        path_or_fileobj=report_path,
+        path_in_repo="results/post-train-report.json",
+        repo_id=ADAPTER_REPO,
+        repo_type="model",
+        commit_message="Post-training report",
+    )
+except:
+    pass  # Adapter repo might not accept it, that's fine
+
+# ═════════════════════════════════════════════════════════════
+# Summary
+# ═════════════════════════════════════════════════════════════
+print("\n" + "="*60)
+print("📋 FINAL SUMMARY")
+print("="*60)
+print(f"Adapter:   https://huggingface.co/{ADAPTER_REPO}")
+print(f"Merged:    https://huggingface.co/{MERGED_REPO}")
+if REPORT["steps"]["gguf"]["status"] == "success":
+    print(f"GGUF:      {MERGED_REPO}/gguf/sakthai-7b-tools-Q4_K_M.gguf")
+print(f"Benchmark: {passed}/{total} tests passed")
+print(f"\n✅ Pipeline complete!")
+print("="*60)
+
+# Print detailed benchmark
+print(f"\n{'='*60}")
+print("📊 DETAILED BENCHMARK RESULTS")
+print(f"{'='*60}")
+for r in benchmark_results:
+    icon = "✅" if r["passed"] else "❌"
+    print(f"  {icon} {r['test']}")
+print(f"  {'='*50}")
+print(f"  Total: {passed}/{total} passed")