File size: 11,333 Bytes

8567b2b

#!/usr/bin/env bash
#SBATCH --job-name=27b_beam_eval
#SBATCH --mail-user=josuetf@umich.edu
#SBATCH --mail-type=ALL
#SBATCH --output=/nfs/turbo/coe-chaijy-unreplicated/josuetf/LMPlayschool/playpen/slurm/%x_%j.out
#SBATCH --partition=spgpu
#SBATCH --time=3-0:00:00
#SBATCH --gpus=8
#SBATCH --cpus-per-gpu=4
#SBATCH --mem-per-gpu=48GB
#SBATCH --account=chaijy0

# Produces the same clemscore + statscore as `playpen eval --suite all` for two models:
#   - Baseline: Qwen3.5-27B-Instruct-4bit (greedy, no PRM)
#   - Guided:   Qwen3.5-27B-sft-ep1-4bit + PRM (beam search N=4, M=4, 20 iters)
#
# Beam search parameters (SAL paper low-budget config):
#   N = 4 total beams; M = beam_width = 4; prune to N/M = 1 survivor per step.
#   Survivor is expanded back to N=4 for the next step. Max 20 steps per turn.
#   Steps are delimited by \n\n (reasoning paragraph → action line).
#
# GPU layout (dynamic — handles any node count and uneven GPU splits):
#   Phase 1 (all GPUs in parallel across all nodes):
#     Global shards 0 .. HALF-1:             baseline (greedy, first half of GPUs)
#     Global shards HALF .. WORLD_GPUS-1:    beam-search guided (second half of GPUs)
#   Phase 2 (2 GPUs on head node, after Phase 1):
#     GPU 0: static eval for baseline
#     GPU 1: static eval for guided
#   Phase 3 (CPU): merge shards, score, compute clemscore, print comparison

set -euo pipefail

WORKDIR="/nfs/turbo/coe-chaijy-unreplicated/josuetf/LMPlayschool/playpen"
CONDA_ENV="playpen"

export BASE_MODEL="${BASE_MODEL:-Qwen3.5-27B-Instruct-4bit}"
export GUIDED_MODEL="${GUIDED_MODEL:-Qwen3.5-27B-sft-ep1-4bit}"
export PRM_PATH="${PRM_PATH:-models/prm/Qwen3.5-27B-sft-ep1-4bit-1024-full/bench}"
export N_BEAMS="${N_BEAMS:-4}"
export NUM_BEAM_ITERS="${NUM_BEAM_ITERS:-20}"
export RESULTS_DIR="${RESULTS_DIR:-eval-results-27b-beam}"

export BASE_RESULTS_DIR="${RESULTS_DIR}-base"
export GUIDED_RESULTS_DIR="${RESULTS_DIR}-guided"

cd "$WORKDIR"
mkdir -p slurm logs

source "$(conda info --base)/etc/profile.d/conda.sh"
conda activate "$CONDA_ENV"
export PYTHONNOUSERSITE=1
export PYTORCH_CUDA_ALLOC_CONF="${PYTORCH_CUDA_ALLOC_CONF:-expandable_segments:True}"

# -----------------------------------------------------------------------
# Topology detection
# -----------------------------------------------------------------------
if [ -n "${SLURM_JOB_ID:-}" ]; then
    NNODES="${SLURM_NNODES:-1}"
    total_gpus=""
    if command -v scontrol &>/dev/null; then
        total_gpus="$(scontrol show job "$SLURM_JOB_ID" 2>/dev/null \
                      | grep -oE 'gres/gpu=[0-9]+' | head -1 \
                      | grep -oE '[0-9]+' || true)"
    fi
    [ -z "$total_gpus" ] && total_gpus="${SLURM_GPUS:-}"
    total_gpus="${total_gpus##*:}"
    case "$total_gpus" in
        ''|*[!0-9]*) total_gpus=$(( ${SLURM_GPUS_ON_NODE:-$(nvidia-smi -L 2>/dev/null | wc -l)} * NNODES )) ;;
    esac
else
    NNODES=1
    total_gpus=$(nvidia-smi -L 2>/dev/null | wc -l)
fi
[ "${total_gpus:-0}" -ge 1 ] || total_gpus=1
GPUS_PER_NODE=$(( total_gpus / NNODES ))
[ "$GPUS_PER_NODE" -ge 1 ] || GPUS_PER_NODE=1

NODE_OFFSETS=""
WORLD_GPUS=0
if [ "$NNODES" -gt 1 ]; then
    _probe="$(srun --ntasks="$NNODES" --ntasks-per-node=1 --gpu-bind=none \
                 bash -c 'echo "$SLURM_NODEID $(nvidia-smi -L 2>/dev/null | wc -l)"' \
                 2>/dev/null | sort -n || true)"
    _acc=0
    while read -r _nid _cnt; do
        [ -n "${_cnt:-}" ] || continue
        NODE_OFFSETS="$NODE_OFFSETS $_acc"
        _acc=$(( _acc + _cnt ))
    done <<< "$_probe"
    WORLD_GPUS="$_acc"
    NODE_OFFSETS="${NODE_OFFSETS# }"
fi
if [ -z "$NODE_OFFSETS" ] || [ "$WORLD_GPUS" -lt 1 ]; then
    _acc=0
    for (( _n=0; _n<NNODES; _n++ )); do
        NODE_OFFSETS="$NODE_OFFSETS $_acc"
        _acc=$(( _acc + GPUS_PER_NODE ))
    done
    WORLD_GPUS=$(( NNODES * GPUS_PER_NODE ))
    NODE_OFFSETS="${NODE_OFFSETS# }"
fi

HALF=$(( WORLD_GPUS / 2 ))
[ "$HALF" -ge 1 ] || { echo "ERROR: need at least 2 GPUs total (got $WORLD_GPUS)"; exit 1; }
BASE_SHARDS=$HALF
GUIDED_SHARDS=$(( WORLD_GPUS - HALF ))

export NODE_OFFSETS WORLD_GPUS HALF BASE_SHARDS GUIDED_SHARDS WORKDIR

echo "=============================="
echo "Job ID:    ${SLURM_JOB_ID:-<direct>}"
echo "Nodes:     $NNODES  ($WORLD_GPUS total GPUs)"
echo "Offsets:   $NODE_OFFSETS"
echo "Baseline:  $BASE_MODEL  ($BASE_SHARDS shards, greedy)"
echo "Guided:    $GUIDED_MODEL + PRM  ($GUIDED_SHARDS shards, beam-search N=$N_BEAMS iters=$NUM_BEAM_ITERS)"
echo "PRM:       $PRM_PATH"
echo "Base dir:  $BASE_RESULTS_DIR"
echo "Guided dir:$GUIDED_RESULTS_DIR"
echo "Started:   $(date)"
echo "=============================="

# -----------------------------------------------------------------------
# Phase 1: Clem gameplay — all GPUs in parallel across all nodes.
# -----------------------------------------------------------------------
echo ""
echo "=== Phase 1: Clem gameplay ($WORLD_GPUS GPU(s) across $NNODES node(s)) ==="

fail=0
srun --ntasks="$NNODES" --ntasks-per-node=1 --gpu-bind=none \
     bash -c '
        cd "$WORKDIR"
        lg=$(nvidia-smi -L 2>/dev/null | wc -l); [ "$lg" -ge 1 ] || lg=1
        off=$(echo "$NODE_OFFSETS" | cut -d" " -f$((SLURM_NODEID+1))); [ -n "$off" ] || off=0
        pids=()
        for (( g=0; g<lg; g++ )); do
            gsid=$(( off + g ))
            if (( gsid < HALF )); then
                log="logs/eval_27b_base_shard$(printf "%02d" $gsid).log"
                echo "  [node $SLURM_NODEID gpu $g] baseline shard $gsid/$BASE_SHARDS -> $log"
                CUDA_VISIBLE_DEVICES=$g \
                    python examples/trl/prm_eval.py \
                        --policy-model "$BASE_MODEL" \
                        --temperature 0.0 \
                        --max-tokens 300 \
                        --game-all \
                        --results-dir "$BASE_RESULTS_DIR" \
                        --shard-id "$gsid" --num-shards "$BASE_SHARDS" \
                        --skip-guided --skip-score \
                    > "$log" 2>&1 &
            else
                guided_sid=$(( gsid - HALF ))
                log="logs/eval_27b_beam_shard$(printf "%02d" $guided_sid).log"
                echo "  [node $SLURM_NODEID gpu $g] beam-search shard $guided_sid/$GUIDED_SHARDS -> $log"
                CUDA_VISIBLE_DEVICES=$g \
                    python examples/trl/prm_eval.py \
                        --prm-path "$PRM_PATH" \
                        --policy-model "$GUIDED_MODEL" \
                        --mode beam-search \
                        --n-candidates "$N_BEAMS" \
                        --num-beam-iterations "$NUM_BEAM_ITERS" \
                        --temperature 0.7 \
                        --max-tokens 2048 \
                        --game-all \
                        --results-dir "$GUIDED_RESULTS_DIR" \
                        --shard-id "$guided_sid" --num-shards "$GUIDED_SHARDS" \
                        --skip-baseline --skip-score \
                    > "$log" 2>&1 &
            fi
            pids+=($!)
        done
        rc=0
        for p in "${pids[@]}"; do wait "$p" || rc=1; done
        exit $rc
     ' || fail=$?

echo "Phase 1 done (fail=$fail) at $(date)"

# -----------------------------------------------------------------------
# Phase 2: Static eval — head node GPU 0 and GPU 1
# -----------------------------------------------------------------------
echo ""
echo "=== Phase 2: Static eval (GPUs 0,1 on head node) ==="
CUDA_VISIBLE_DEVICES=0 playpen eval "$BASE_MODEL"   --suite static -r "$RESULTS_DIR/base-static" \
    > "logs/eval_27b_base_static.log" 2>&1 &
CUDA_VISIBLE_DEVICES=1 playpen eval "$GUIDED_MODEL" --suite static -r "$RESULTS_DIR/guided-static" \
    > "logs/eval_27b_guided_static.log" 2>&1 &
wait
echo "Phase 2 done at $(date)"

# -----------------------------------------------------------------------
# Phase 3: Merge + score + clemscore
# -----------------------------------------------------------------------
echo ""
echo "=== Phase 3: Merge + score ==="
python - <<'PY'
import sys, json, os
from pathlib import Path

sys.path.insert(0, "examples/trl")
from prm_eval import _merge_results, _clem_score
import clemcore.clemeval as clemeval

RESULTS_DIR         = os.environ["RESULTS_DIR"]
BASE_RESULTS_DIR    = os.environ["BASE_RESULTS_DIR"]
GUIDED_RESULTS_DIR  = os.environ["GUIDED_RESULTS_DIR"]
BASE_SHARDS         = int(os.environ["BASE_SHARDS"])
GUIDED_SHARDS       = int(os.environ["GUIDED_SHARDS"])
BASE_MODEL          = os.environ["BASE_MODEL"]
GUIDED_MODEL        = os.environ["GUIDED_MODEL"]
N_BEAMS             = os.environ.get("N_BEAMS", "4")

base_dir   = Path(BASE_RESULTS_DIR)
guided_dir = Path(GUIDED_RESULTS_DIR)

print(f"Merging {BASE_SHARDS} baseline shard(s) into {base_dir} ...")
_merge_results(base_dir, BASE_SHARDS)

print(f"Merging {GUIDED_SHARDS} guided shard(s) into {guided_dir} ...")
_merge_results(guided_dir, GUIDED_SHARDS)

baseline_clem = base_dir   / "baseline"
guided_clem   = guided_dir / "prm-guided"

for label, results in [("baseline", baseline_clem), ("guided", guided_clem)]:
    if not results.exists():
        print(f"WARNING: {results} not found, skipping scoring")
        continue
    games = sorted({p.name for p in results.glob("*/epoch_00001/*") if p.is_dir()})
    print(f"Scoring {label}: {games}")
    for g in games:
        _clem_score(results, g)

def get_clemscore(results_path):
    if not results_path.exists():
        return float("nan")
    try:
        df = clemeval.perform_evaluation(str(results_path), return_dataframe=True)
        return round(df["-, clemscore"][0], 2)
    except Exception as e:
        print(f"  clemeval failed on {results_path}: {e}")
        return float("nan")

base_clemscore   = get_clemscore(baseline_clem)
guided_clemscore = get_clemscore(guided_clem)

def get_statscore(static_results_dir, model_name):
    val_json = static_results_dir / f"{model_name}.val.json"
    if val_json.exists():
        data = json.loads(val_json.read_text())
        return round(data.get("statscore", float("nan")), 2)
    return float("nan")

static_base   = Path(RESULTS_DIR) / "base-static"
static_guided = Path(RESULTS_DIR) / "guided-static"
base_statscore   = get_statscore(static_base,   BASE_MODEL)
guided_statscore = get_statscore(static_guided, GUIDED_MODEL)

print()
print("=" * 60)
print(f"{'':30s}  {'Baseline':>10}  {'Beam-guided':>11}  {'Δ':>6}")
print(f"{'Model':30s}  {BASE_MODEL[-10:]:>10}  {GUIDED_MODEL[-11:]:>11}")
print(f"{'Search':30s}  {'greedy':>10}  {f'beam N={N_BEAMS}':>11}")
print("-" * 60)
print(f"{'clemscore':30s}  {base_clemscore:>10.2f}  {guided_clemscore:>11.2f}  {guided_clemscore - base_clemscore:>+6.2f}")
print(f"{'statscore':30s}  {base_statscore:>10.2f}  {guided_statscore:>11.2f}  {guided_statscore - base_statscore:>+6.2f}")
print("=" * 60)

for model, clem_s, stat_s, static_dir in [
    (BASE_MODEL,   base_clemscore,   base_statscore,   static_base),
    (GUIDED_MODEL, guided_clemscore, guided_statscore, static_guided),
]:
    out = static_dir / f"{model}.val.json"
    out.parent.mkdir(parents=True, exist_ok=True)
    out.write_text(json.dumps({"clemscore": clem_s, "statscore": stat_s}, indent=2))
    print(f"Wrote {out}")
PY

echo ""
echo "=============================="
echo "Done: $(date)"
echo "=============================="

exit $fail