grpo_train.py

"""
BioForge GRPO training.
Fine-tunes a (SFT-warm-started) Llama-3.1-8B-Instruct with Group Relative
Policy Optimisation (GRPO) using TRL + Unsloth, with BioForge reward functions
as verifiers.

Usage:
  python train/grpo_train.py \
    --model outputs/bioforge-sft/merged \
    --env_url http://localhost:7860 \
    --out outputs/bioforge-grpo \
    --steps 2000 --batch 64

Environment variables:
  WANDB_PROJECT   — W&B project name (optional)
  HF_TOKEN        — HF API key for uploading (optional)
"""
from __future__ import annotations

import argparse
import json
import os
import random
import re
import sys
import time
import uuid
from pathlib import Path
from typing import Any, Dict, List, Optional

import httpx
import torch
from datasets import Dataset

try:
    from unsloth import FastLanguageModel, PatchFastRL
    PatchFastRL("GRPO", FastLanguageModel)
    UNSLOTH = True
except ImportError:
    UNSLOTH = False

from trl import GRPOConfig, GRPOTrainer

# Ensure parent on path
ROOT = Path(__file__).parent.parent
sys.path.insert(0, str(ROOT))

# ─────────────────────────────────────────────────────────────────────────────
# Environment interaction
# ─────────────────────────────────────────────────────────────────────────────

def env_reset(base_url: str, task_id: str, difficulty: str) -> Dict[str, Any]:
    resp = httpx.post(
        f"{base_url}/reset",
        json={"task_id": task_id, "difficulty": difficulty, "payload": {}},
        timeout=30.0,
    )
    resp.raise_for_status()
    d = resp.json()
    return d.get("observation", d)


def env_step(base_url: str, action: Dict[str, Any]) -> Dict[str, Any]:
    resp = httpx.post(f"{base_url}/step", json=action, timeout=30.0)
    resp.raise_for_status()
    d = resp.json()
    return d.get("observation", d)


# ─────────────────────────────────────────────────────────────────────────────
# Reward function (used by GRPOTrainer as reward_fn)
# ─────────────────────────────────────────────────────────────────────────────

ENV_URL: str = ""  # set at training time

TASK_LIST = [
    ("variant_triage", "easy"),
    ("pharmacogenomics", "easy"),
    ("drug_synergy", "medium"),
    ("genetic_counseling", "medium"),
    ("neoantigen_vaccine", "hard"),
]


def extract_json_safe(text: str) -> Optional[Dict[str, Any]]:
    """Extract JSON from model generation."""
    fence_match = re.search(r"```(?:json)?\s*(\{.*?\})\s*```", text, re.DOTALL)
    if fence_match:
        candidate = fence_match.group(1)
    else:
        brace_match = re.search(r"\{.*\}", text, re.DOTALL)
        if not brace_match:
            return None
        candidate = brace_match.group(0)
    try:
        return json.loads(candidate)
    except json.JSONDecodeError:
        return None


def bioforge_reward_fn(completions: List[str], prompts: List[str], **kwargs) -> List[float]:
    """
    TRL GRPO reward function.
    Each completion is a model generation; we step the env once and return the reward.
    The task/difficulty are injected via kwargs from the dataset.
    """
    rewards: List[float] = []
    task_ids: List[str] = kwargs.get("task_id", ["variant_triage"] * len(completions))
    difficulties: List[str] = kwargs.get("difficulty", ["easy"] * len(completions))
    episode_obs_list: List[Dict[str, Any]] = kwargs.get("episode_obs", [{}] * len(completions))

    for completion, task_id, difficulty, obs in zip(completions, task_ids, difficulties, episode_obs_list):
        action_dict = extract_json_safe(completion)
        if action_dict is None:
            rewards.append(-0.1)  # penalty for invalid JSON
            continue

        action_payload = {
            "task_id": task_id,
            "difficulty": difficulty,
            "payload": action_dict,
        }
        try:
            step_obs = env_step(ENV_URL, action_payload)
            reward = float(step_obs.get("reward", 0.0))
        except Exception:
            reward = 0.0

        rewards.append(reward)

    return rewards


# ─────────────────────────────────────────────────────────────────────────────
# Rollout dataset builder
# ─────────────────────────────────────────────────────────────────────────────

def build_rollout_dataset(n_prompts: int = 500) -> Dataset:
    """
    Build prompts for GRPO by resetting the environment and extracting initial observations.
    Each row: {prompt, task_id, difficulty, episode_obs}.
    """
    from bioforge.inference import SYSTEM_PROMPTS, build_user_prompt  # lazy import

    records = []
    rng = random.Random(42)
    for _ in range(n_prompts):
        task_id, difficulty = rng.choice(TASK_LIST)
        try:
            obs = env_reset(ENV_URL, task_id, difficulty)
        except Exception:
            obs = {}

        system = SYSTEM_PROMPTS.get(task_id, "You are a biomedical AI agent. Output JSON.")
        user = build_user_prompt(task_id, obs)
        prompt = f"<|system|>{system}<|end|>\n<|user|>{user}<|end|>\n<|assistant|>"

        records.append({
            "prompt": prompt,
            "task_id": task_id,
            "difficulty": difficulty,
            "episode_obs": obs,
        })

    return Dataset.from_list(records)


# ─────────────────────────────────────────────────────────────────────────────
# Main
# ─────────────────────────────────────────────────────────────────────────────

def main() -> None:
    global ENV_URL

    parser = argparse.ArgumentParser()
    parser.add_argument("--model", default="unsloth/Qwen2.5-3B-Instruct",
                        help="Base model or fine-tuned checkpoint. Default: Qwen2.5-3B-Instruct (fits T4 16GB)")
    parser.add_argument("--env_url", default="http://localhost:7860")
    parser.add_argument("--out", default="outputs/bioforge-grpo")
    parser.add_argument("--steps", type=int, default=500,
                        help="GRPO training steps. 500=quick (~1hr T4), 2000=full")
    parser.add_argument("--batch", type=int, default=8)
    parser.add_argument("--n_prompts", type=int, default=300)
    parser.add_argument("--max_seq_length", type=int, default=1536)
    parser.add_argument("--lr", type=float, default=5e-6)
    parser.add_argument("--push_to_hub", default="",
                        help="HF repo id to push trained model (e.g. user/bioforge-grpo)")
    args = parser.parse_args()

    ENV_URL = args.env_url.rstrip("/")

    # Load model
    if UNSLOTH:
        model, tokenizer = FastLanguageModel.from_pretrained(
            model_name=args.model,
            max_seq_length=args.max_seq_length,
            dtype=None,
            load_in_4bit=True,
        )
        model = FastLanguageModel.get_peft_model(
            model, r=16,
            target_modules=["q_proj", "k_proj", "v_proj", "o_proj",
                             "gate_proj", "up_proj", "down_proj"],
            lora_alpha=16, lora_dropout=0.0, bias="none",
            use_gradient_checkpointing="unsloth",
        )
    else:
        from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig
        from peft import LoraConfig, get_peft_model
        tokenizer = AutoTokenizer.from_pretrained(args.model)
        tokenizer.pad_token = tokenizer.eos_token
        model = AutoModelForCausalLM.from_pretrained(
            args.model,
            quantization_config=BitsAndBytesConfig(load_in_4bit=True, bnb_4bit_compute_dtype=torch.float16),
            device_map="auto",
        )
        model = get_peft_model(model, LoraConfig(r=16, lora_alpha=16, target_modules=["q_proj", "v_proj"]))

    # Build dataset
    print(f"[GRPO] Building rollout dataset ({args.n_prompts} prompts)...")
    dataset = build_rollout_dataset(args.n_prompts)

    out_dir = Path(args.out)
    out_dir.mkdir(parents=True, exist_ok=True)

    grpo_config = GRPOConfig(
        output_dir=str(out_dir),
        max_steps=args.steps,
        num_generations=8,           # G in GRPO: rollouts per prompt
        per_device_train_batch_size=args.batch // 8,
        gradient_accumulation_steps=8,
        learning_rate=args.lr,
        lr_scheduler_type="cosine",
        warmup_ratio=0.05,
        max_completion_length=512,
        temperature=0.9,
        top_p=0.95,
        logging_steps=5,
        save_steps=200,
        save_total_limit=2,
        report_to="wandb" if os.environ.get("WANDB_PROJECT") else "none",
        run_name="bioforge-grpo",
        bf16=torch.cuda.is_bf16_supported(),
        fp16=not torch.cuda.is_bf16_supported(),
    )

    trainer = GRPOTrainer(
        model=model,
        processing_class=tokenizer,
        config=grpo_config,
        train_dataset=dataset,
        reward_funcs=bioforge_reward_fn,
    )

    print(f"[GRPO] Starting GRPO training for {args.steps} steps...")
    trainer.train()

    if UNSLOTH:
        model.save_pretrained_merged(str(out_dir / "merged"), tokenizer, save_method="merged_16bit")
    else:
        model.save_pretrained(str(out_dir))
        tokenizer.save_pretrained(str(out_dir))

    print(f"[GRPO] Training complete. Model saved to {out_dir}")

    if args.push_to_hub:
        hf_token = os.environ.get("HF_TOKEN", "")
        if UNSLOTH:
            model.push_to_hub_merged(
                args.push_to_hub, tokenizer, save_method="lora", token=hf_token,
                commit_message="BioForge GRPO fine-tuned",
            )
        else:
            model.push_to_hub(args.push_to_hub, token=hf_token)
            tokenizer.push_to_hub(args.push_to_hub, token=hf_token)
        print(f"[GRPO] Pushed to https://huggingface.co/{args.push_to_hub}")


if __name__ == "__main__":
    main()