Upload hf_sft_train.py with huggingface_hub

hf_sft_train.py

@@ -0,0 +1,268 @@
+# /// 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 SFT Training Job — runs on Hugging Face Jobs cloud GPU.
+
+This script:
+  1. Clones the project from GitHub
+  2. Installs the polyguard-rl package
+  3. Generates the SFT dataset from the PolyGuard environment
+  4. Fine-tunes Qwen2.5-1.5B-Instruct with LoRA via TRL SFTTrainer
+  5. Pushes the LoRA adapter + tokenizer to the Hugging Face Hub
+
+Submit via CLI:
+  hf jobs uv run \
+    --flavor a10g-large \
+    --timeout 3h \
+    --secrets HF_TOKEN \
+    "https://huggingface.co/TheJackBright/polyguard-training-scripts/resolve/main/hf_sft_train.py"
+
+Environment variables (passed as --env or via job secrets):
+  HF_TOKEN          : HF write token (required for Hub push)
+  GITHUB_REPO       : override GitHub repo URL (optional)
+  MODEL_NAME        : base model (default: Qwen/Qwen2.5-1.5B-Instruct)
+  HUB_MODEL_ID      : output model repo on Hub (default: TheJackBright/polyguard-qwen-sft)
+  N_EPISODES        : SFT dataset episodes (default: 500)
+  EPOCHS            : training epochs (default: 3)
+  BATCH_SIZE        : per-device batch size (default: 2)
+  GRAD_ACCUM        : gradient accumulation steps (default: 8)
+  MAX_LENGTH        : max token length (default: 1024)
+  LEARNING_RATE     : learning rate (default: 2e-4)
+  LORA_RANK         : LoRA rank (default: 16)
+"""
+from __future__ import annotations
+
+import inspect
+import json
+import os
+import random
+import subprocess
+import sys
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+# ─── Config from environment ────────────────────────────────────────────────
+GITHUB_REPO   = os.environ.get("GITHUB_REPO", "https://github.com/Vishwa-docs/Meta_PyTorch_Scalar_OpenEnv-Hackathon.git")
+MODEL_NAME    = os.environ.get("MODEL_NAME", "Qwen/Qwen2.5-1.5B-Instruct")
+HUB_MODEL_ID  = os.environ.get("HUB_MODEL_ID", "TheJackBright/polyguard-qwen-sft")
+N_EPISODES    = int(os.environ.get("N_EPISODES", "500"))
+EPOCHS        = int(os.environ.get("EPOCHS", "3"))
+BATCH_SIZE    = int(os.environ.get("BATCH_SIZE", "2"))
+GRAD_ACCUM    = int(os.environ.get("GRAD_ACCUM", "8"))
+MAX_LENGTH    = int(os.environ.get("MAX_LENGTH", "1024"))
+LEARNING_RATE = float(os.environ.get("LEARNING_RATE", "2e-4"))
+LORA_RANK     = int(os.environ.get("LORA_RANK", "16"))
+SEED          = 42
+OUTPUT_DIR    = "/tmp/polyguard_sft_output"
+DATA_PATH     = "/tmp/polyguard_sft_data.jsonl"
+DATA_FMT_PATH = "/tmp/polyguard_sft_data_formatted.jsonl"
+
+SYSTEM_PROMPT = (
+    "You are a clinical pharmacist agent performing polypharmacy medication review. "
+    "Analyze drug-drug interactions, Beers criteria violations, and propose safe interventions. "
+    "Respond only with a structured <decision>...</decision> XML action."
+)
+
+print("=" * 60)
+print("PolyGuard SFT Training on HF Jobs")
+print(f"  Model:        {MODEL_NAME}")
+print(f"  Hub output:   {HUB_MODEL_ID}")
+print(f"  Episodes:     {N_EPISODES}")
+print(f"  Epochs:       {EPOCHS}")
+print(f"  Batch size:   {BATCH_SIZE} x {GRAD_ACCUM} grad accum")
+print(f"  Max length:   {MAX_LENGTH}")
+print(f"  LoRA rank:    {LORA_RANK}")
+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,
+    )
+    print(f"  Cloned to {clone_dir}")
+else:
+    print(f"  Already cloned at {clone_dir}")
+
+polyguard_rl_dir = clone_dir / "polyguard-rl"
+print(f"\n[2/5] Installing polyguard-rl from {polyguard_rl_dir}...")
+subprocess.run(
+    [sys.executable, "-m", "pip", "install", "-e", str(polyguard_rl_dir), "--quiet"],
+    check=True,
+)
+print("  polyguard-rl installed.")
+
+# Add to sys.path so relative imports work during dataset generation
+if str(polyguard_rl_dir) not in sys.path:
+    sys.path.insert(0, str(polyguard_rl_dir))
+
+
+# ─── Step 2: Generate SFT dataset ───────────────────────────────────────────
+print(f"\n[3/5] Generating SFT dataset ({N_EPISODES} episodes)...")
+
+os.chdir(polyguard_rl_dir)
+
+from app.training.sft_dataset import generate_sft_dataset, build_external_ddi_sft_examples, format_for_training  # noqa: E402
+
+examples = generate_sft_dataset(
+    n_episodes=N_EPISODES,
+    seed=SEED,
+    output_path=DATA_PATH,
+)
+
+print(f"  Generated {len(examples)} episodes.")
+
+# Format for TRL (convert to messages format)
+formatted = format_for_training(examples, system_prompt=SYSTEM_PROMPT)
+print(f"  Formatted {len(formatted)} training rows.")
+
+with open(DATA_FMT_PATH, "w") as f:
+    for row in formatted:
+        f.write(json.dumps(row) + "\n")
+
+print(f"  Saved formatted dataset to {DATA_FMT_PATH}")
+
+
+# ─── Step 3: Load model with LoRA ───────────────────────────────────────────
+print(f"\n[4/5] Loading model and running SFT training...")
+
+import torch
+from datasets import Dataset
+from peft import LoraConfig, get_peft_model
+from transformers import AutoModelForCausalLM, AutoTokenizer
+from trl import SFTConfig, SFTTrainer
+
+device_map = "auto" if torch.cuda.is_available() else "cpu"
+dtype = torch.bfloat16 if (torch.cuda.is_available() and torch.cuda.is_bf16_supported()) else torch.float16
+
+print(f"  CUDA available: {torch.cuda.is_available()}")
+if torch.cuda.is_available():
+    print(f"  GPU: {torch.cuda.get_device_name(0)}")
+    print(f"  VRAM: {torch.cuda.get_device_properties(0).total_memory / 1e9:.1f} GB")
+
+print(f"  Loading tokenizer from {MODEL_NAME}...")
+tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME, trust_remote_code=True)
+if tokenizer.pad_token is None:
+    tokenizer.pad_token = tokenizer.eos_token
+    tokenizer.pad_token_id = tokenizer.eos_token_id
+
+print(f"  Loading base model...")
+model = AutoModelForCausalLM.from_pretrained(
+    MODEL_NAME,
+    torch_dtype=dtype,
+    device_map=device_map,
+    trust_remote_code=True,
+)
+
+lora_config = LoraConfig(
+    r=LORA_RANK,
+    lora_alpha=LORA_RANK * 2,
+    target_modules=["q_proj", "k_proj", "v_proj", "o_proj", "gate_proj", "up_proj", "down_proj"],
+    lora_dropout=0.05,
+    bias="none",
+    task_type="CAUSAL_LM",
+)
+model = get_peft_model(model, lora_config)
+model.print_trainable_parameters()
+
+
+# ─── Step 4: Build dataset and trainer ──────────────────────────────────────
+random.seed(SEED)
+ds_full = Dataset.from_list(formatted).shuffle(seed=SEED)
+split = ds_full.train_test_split(test_size=0.1, seed=SEED)
+
+sft_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": LEARNING_RATE,
+    "warmup_ratio": 0.05,
+    "weight_decay": 0.01,
+    "bf16": dtype == torch.bfloat16,
+    "fp16": dtype == torch.float16,
+    "logging_steps": 10,
+    "save_steps": 100,
+    "save_total_limit": 2,
+    "max_grad_norm": 1.0,
+    "seed": SEED,
+    "report_to": ["trackio"],
+    "run_name": "polyguard-sft-qwen",
+    "project": "polyguard-training",
+    "push_to_hub": True,
+    "hub_model_id": HUB_MODEL_ID,
+    "hub_strategy": "every_save",
+    "eval_strategy": "steps",
+    "eval_steps": 50,
+}
+
+# Adapt to TRL version
+sft_params = set(inspect.signature(SFTConfig).parameters)
+if "max_length" in sft_params:
+    sft_config_kwargs["max_length"] = MAX_LENGTH
+elif "max_seq_length" in sft_params:
+    sft_config_kwargs["max_seq_length"] = MAX_LENGTH
+if "eos_token" in sft_params:
+    sft_config_kwargs["eos_token"] = "<|im_end|>"
+
+sft_config = SFTConfig(**{k: v for k, v in sft_config_kwargs.items() if k in sft_params})
+
+trainer_kwargs: Dict[str, Any] = {
+    "model": model,
+    "args": sft_config,
+    "train_dataset": split["train"],
+    "eval_dataset": split["test"],
+}
+trainer_params = set(inspect.signature(SFTTrainer).parameters)
+if "processing_class" in trainer_params:
+    trainer_kwargs["processing_class"] = tokenizer
+elif "tokenizer" in trainer_params:
+    trainer_kwargs["tokenizer"] = tokenizer
+
+trainer = SFTTrainer(**{k: v for k, v in trainer_kwargs.items() if v is not None})
+
+print(f"\n  Training dataset: {len(split['train'])} rows")
+print(f"  Eval dataset:     {len(split['test'])} rows")
+print("\n  Starting training...\n")
+
+
+# ─── Step 5: Train and push to Hub ─────────────────────────────────────────
+train_result = trainer.train()
+
+print("\n  Training complete.")
+print(f"  Train loss:   {train_result.training_loss:.4f}")
+print(f"  Train steps:  {train_result.global_step}")
+
+print(f"\n[5/5] Pushing model to Hub: {HUB_MODEL_ID}...")
+trainer.push_to_hub()
+tokenizer.push_to_hub(HUB_MODEL_ID)
+
+print("\n" + "=" * 60)
+print("SFT training complete!")
+print(f"Model saved to: https://huggingface.co/{HUB_MODEL_ID}")
+print("=" * 60)