Upload hf_grpo_train.py with huggingface_hub

hf_grpo_train.py

@@ -0,0 +1,275 @@
+# /// script
+# dependencies = [
+#   "torch>=2.2.0",
+#   "transformers>=4.40.0",
+#   "trl>=1.2.0",
+#   "peft>=0.10.0",
+#   "accelerate>=0.27.0",
+#   "bitsandbytes>=0.43.0",
+#   "datasets>=2.18.0",
+#   "huggingface-hub>=0.22.0",
+#   "trackio",
+#   "pydantic>=2.0",
+#   "numpy>=1.24",
+#   "pandas>=2.0",
+#   "matplotlib>=3.8",
+#   "tqdm>=4.60",
+#   "networkx>=3.0",
+#   "scipy>=1.10",
+#   "fastapi>=0.100",
+#   "uvicorn>=0.22",
+#   "httpx>=0.24",
+#   "pyyaml>=6.0",
+# ]
+# ///
+"""
+PolyGuard GRPO Training Job — runs on Hugging Face Jobs cloud GPU.
+
+This script:
+  1. Clones the project from GitHub
+  2. Installs the polyguard-rl package
+  3. Loads the SFT adapter from Hub (or base model if no adapter)
+  4. Generates GRPO rollout prompts from the PolyGuard environment
+  5. Runs GRPO training with 4 grouped reward functions
+  6. Pushes the final adapter to the Hugging Face Hub
+
+Submit via CLI:
+  hf jobs uv run \
+    --flavor a10g-large \
+    --timeout 4h \
+    --secrets HF_TOKEN \
+    "https://huggingface.co/TheJackBright/polyguard-training-scripts/resolve/main/hf_grpo_train.py"
+
+Environment variables:
+  HF_TOKEN          : HF write token (required, passed via --secrets)
+  SFT_MODEL_ID      : SFT adapter on Hub (default: TheJackBright/polyguard-qwen-sft)
+  HUB_MODEL_ID      : output GRPO model repo (default: TheJackBright/polyguard-qwen-grpo)
+  N_EPISODES        : GRPO rollout episodes (default: 256)
+  EPOCHS            : training epochs (default: 2)
+  BATCH_SIZE        : per-device train batch size (default: 2)
+  GRAD_ACCUM        : gradient accumulation steps (default: 8)
+  MAX_PROMPT_LEN    : max prompt tokens (default: 512)
+  MAX_COMPLETION_LEN: max completion tokens (default: 512)
+  GROUP_SIZE        : GRPO group size (default: 4)
+"""
+from __future__ import annotations
+
+import inspect
+import json
+import os
+import subprocess
+import sys
+from pathlib import Path
+from typing import Any, Callable, Dict, List, Optional
+
+# ─── Config from environment ────────────────────────────────────────────────
+GITHUB_REPO        = os.environ.get("GITHUB_REPO", "https://github.com/Vishwa-docs/Meta_PyTorch_Scalar_OpenEnv-Hackathon.git")
+SFT_MODEL_ID       = os.environ.get("SFT_MODEL_ID", "TheJackBright/polyguard-qwen-sft")
+BASE_MODEL_NAME    = os.environ.get("BASE_MODEL_NAME", "Qwen/Qwen2.5-1.5B-Instruct")
+HUB_MODEL_ID       = os.environ.get("HUB_MODEL_ID", "TheJackBright/polyguard-qwen-grpo")
+N_EPISODES         = int(os.environ.get("N_EPISODES", "256"))
+EPOCHS             = int(os.environ.get("EPOCHS", "2"))
+BATCH_SIZE         = int(os.environ.get("BATCH_SIZE", "2"))
+GRAD_ACCUM         = int(os.environ.get("GRAD_ACCUM", "8"))
+MAX_PROMPT_LEN     = int(os.environ.get("MAX_PROMPT_LEN", "512"))
+MAX_COMPLETION_LEN = int(os.environ.get("MAX_COMPLETION_LEN", "512"))
+GROUP_SIZE         = int(os.environ.get("GROUP_SIZE", "4"))
+SEED               = 42
+OUTPUT_DIR         = "/tmp/polyguard_grpo_output"
+PROMPTS_PATH       = "/tmp/polyguard_grpo_prompts.jsonl"
+
+print("=" * 60)
+print("PolyGuard GRPO Training on HF Jobs")
+print(f"  SFT checkpoint: {SFT_MODEL_ID}")
+print(f"  Hub output:     {HUB_MODEL_ID}")
+print(f"  Episodes:       {N_EPISODES}")
+print(f"  Epochs:         {EPOCHS}")
+print(f"  Group size:     {GROUP_SIZE}")
+print("=" * 60)
+
+
+# ─── Step 1: Clone repo and install polyguard-rl ────────────────────────────
+print("\n[1/5] Cloning project from GitHub...")
+clone_dir = Path("/tmp/polyguard_project")
+if not clone_dir.exists():
+    subprocess.run(
+        ["git", "clone", "--depth=1", GITHUB_REPO, str(clone_dir)],
+        check=True,
+    )
+else:
+    print("  Already cloned.")
+
+polyguard_rl_dir = clone_dir / "polyguard-rl"
+print(f"\n[2/5] Installing polyguard-rl...")
+subprocess.run(
+    [sys.executable, "-m", "pip", "install", "-e", str(polyguard_rl_dir), "--quiet"],
+    check=True,
+)
+if str(polyguard_rl_dir) not in sys.path:
+    sys.path.insert(0, str(polyguard_rl_dir))
+os.chdir(polyguard_rl_dir)
+
+
+# ─── Step 2: Build GRPO prompt dataset ──────────────────────────────────────
+print(f"\n[3/5] Building GRPO rollout dataset ({N_EPISODES} episodes)...")
+
+from app.env.env_core import PolyGuardEnv  # noqa: E402
+from app.models.policy.prompt_templates import build_planner_prompt  # noqa: E402
+from app.training.openenv_wrapper import PolyGuardEnvWrapper  # noqa: E402
+
+env = PolyGuardEnv()
+prompts: List[Dict[str, Any]] = []
+
+for ep_idx in range(N_EPISODES):
+    seed_i = SEED + ep_idx
+    obs, _ = env.reset(seed=seed_i)
+    prompt_text = build_planner_prompt(obs)
+    prompts.append({
+        "prompt": prompt_text,
+        "seed": seed_i,
+        "episode": ep_idx,
+        "difficulty": getattr(obs, "difficulty", "medium"),
+    })
+
+print(f"  Built {len(prompts)} GRPO prompts.")
+with open(PROMPTS_PATH, "w") as f:
+    for row in prompts:
+        f.write(json.dumps(row) + "\n")
+
+
+# ─── Step 3: Load model from SFT checkpoint ─────────────────────────────────
+print(f"\n[4/5] Loading SFT model from {SFT_MODEL_ID}...")
+
+import torch
+from datasets import Dataset
+from huggingface_hub import HfApi
+from peft import PeftModel
+from transformers import AutoModelForCausalLM, AutoTokenizer
+from trl import GRPOConfig, GRPOTrainer
+
+dtype = torch.bfloat16 if (torch.cuda.is_available() and torch.cuda.is_bf16_supported()) else torch.float16
+print(f"  CUDA: {torch.cuda.is_available()}")
+if torch.cuda.is_available():
+    print(f"  GPU: {torch.cuda.get_device_name(0)}")
+
+tokenizer = AutoTokenizer.from_pretrained(SFT_MODEL_ID, trust_remote_code=True)
+if tokenizer.pad_token is None:
+    tokenizer.pad_token = tokenizer.eos_token
+
+# Try loading SFT adapter, fall back to base model
+try:
+    base_model = AutoModelForCausalLM.from_pretrained(
+        BASE_MODEL_NAME,
+        torch_dtype=dtype,
+        device_map="auto",
+        trust_remote_code=True,
+    )
+    model = PeftModel.from_pretrained(base_model, SFT_MODEL_ID)
+    print("  Loaded SFT adapter on top of base model.")
+except Exception as e:
+    print(f"  SFT load failed ({e}), falling back to base model...")
+    model = AutoModelForCausalLM.from_pretrained(
+        BASE_MODEL_NAME,
+        torch_dtype=dtype,
+        device_map="auto",
+        trust_remote_code=True,
+    )
+
+
+# ─── Step 4: Build grouped reward function ──────────────────────────────────
+env_wrapper = PolyGuardEnvWrapper(score_timeout_s=30.0)
+
+def build_polyguard_reward_fn(group_name: str) -> Callable:
+    from app.training.grpo_rewards import make_group_reward_fn
+    return make_group_reward_fn(env_wrapper=env_wrapper, group_name=group_name)
+
+# TRL GRPO expects a single reward function that returns List[float]
+# We combine the 4 reward groups into a weighted aggregate
+from app.training.grpo_rewards import REWARD_GROUPS  # noqa: E402
+
+_group_fns = {g: build_polyguard_reward_fn(g) for g in REWARD_GROUPS}
+
+def combined_reward_fn(
+    prompts: List[str],
+    completions: List[str],
+    **kwargs,
+) -> List[float]:
+    weights = {
+        "format_schema": 0.20,
+        "clinical_safety": 0.45,
+        "process_grounding": 0.20,
+        "anti_hack": 0.15,
+    }
+    n = len(prompts)
+    totals = [0.0] * n
+    for group, fn in _group_fns.items():
+        group_rewards = fn(prompts=prompts, completions=completions, **kwargs)
+        w = weights.get(group, 0.25)
+        for i, r in enumerate(group_rewards):
+            totals[i] += w * float(r)
+    # Clamp to [0.001, 0.999]
+    return [max(0.001, min(0.999, round(v, 3))) for v in totals]
+
+
+# ─── Step 5: GRPO Training ──────────────────────────────────────────────────
+ds = Dataset.from_list([{"prompt": p["prompt"]} for p in prompts]).shuffle(seed=SEED)
+
+grpo_config_kwargs: Dict[str, Any] = {
+    "output_dir": OUTPUT_DIR,
+    "num_train_epochs": EPOCHS,
+    "per_device_train_batch_size": BATCH_SIZE,
+    "gradient_accumulation_steps": GRAD_ACCUM,
+    "learning_rate": 1e-5,
+    "bf16": dtype == torch.bfloat16,
+    "fp16": dtype == torch.float16,
+    "logging_steps": 5,
+    "save_steps": 50,
+    "save_total_limit": 2,
+    "seed": SEED,
+    "report_to": ["trackio"],
+    "run_name": "polyguard-grpo-qwen",
+    "project": "polyguard-training",
+    "push_to_hub": True,
+    "hub_model_id": HUB_MODEL_ID,
+    "hub_strategy": "every_save",
+    "num_generations": GROUP_SIZE,
+    "max_prompt_length": MAX_PROMPT_LEN,
+    "max_completion_length": MAX_COMPLETION_LEN,
+    "temperature": 0.9,
+    "beta": 0.1,
+}
+
+grpo_params = set(inspect.signature(GRPOConfig).parameters)
+grpo_config = GRPOConfig(**{k: v for k, v in grpo_config_kwargs.items() if k in grpo_params})
+
+trainer_kwargs: Dict[str, Any] = {
+    "model": model,
+    "args": grpo_config,
+    "train_dataset": ds,
+    "reward_funcs": combined_reward_fn,
+}
+trainer_params = set(inspect.signature(GRPOTrainer).parameters)
+if "processing_class" in trainer_params:
+    trainer_kwargs["processing_class"] = tokenizer
+elif "tokenizer" in trainer_params:
+    trainer_kwargs["tokenizer"] = tokenizer
+
+trainer = GRPOTrainer(**{k: v for k, v in trainer_kwargs.items() if k in trainer_params})
+
+print(f"\n  GRPO dataset size:  {len(ds)}")
+print(f"  Group size:         {GROUP_SIZE}")
+print(f"  Starting GRPO training...\n")
+
+train_result = trainer.train()
+
+print("\n  GRPO training complete.")
+print(f"  Steps: {train_result.global_step}")
+
+print(f"\n[5/5] Pushing GRPO model to Hub: {HUB_MODEL_ID}...")
+trainer.push_to_hub()
+tokenizer.push_to_hub(HUB_MODEL_ID)
+
+print("\n" + "=" * 60)
+print("GRPO training complete!")
+print(f"Model saved to: https://huggingface.co/{HUB_MODEL_ID}")
+print("=" * 60)