run_sft.sh

#!/bin/bash

#SBATCH --job-name=run_sft
#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=14-0:00:00
#SBATCH --gpus=2
#SBATCH --cpus-per-gpu=2
#SBATCH --mem-per-gpu=48GB
#SBATCH --account=chaijy2
# Account chaijy2 cap: gpu=20, cpu=80, mem=960G (shared across the account).
# Every spgpu node has 8x A40 (46GB). Training is data-parallel (DDP): every GPU
# holds a full 4-bit copy of the model and trains on a different data shard.
# COMMAND: sbatch run_sft.sh        (override knobs as VAR=… sbatch run_sft.sh)
# ============================================================================
# Supervised fine-tuning (QLoRA, 4-bit + LoRA) of Qwen3.5-27B on the pre-filtered
# playpen SFT data (scaling_LLM_search_methods/playpen-sft-data/sft-filtered).
#
# This mirrors the TRAINING half of run_prm.sh: detect whatever topology Slurm
# granted (1 node or many), hold the effective batch constant across any GPU
# count by auto-deriving grad-accum, and launch the trainer as DDP via torchrun
# (multi-node spans nodes with srun+torchrun; single-node uses torchrun
# --standalone; a lone GPU uses plain python).
#
# Data route (DATA_ROUTE): which filtered split to train on. Both were verified
# equal to their filter predicate and pre-split train/dev with no task leakage:
#   positive_score -> outcome != 'aborted' AND Main Score > 0   (19,143 train)
#   non_aborted    -> outcome != 'aborted'                      (24,711 train)
#
# RESUME: re-run with RESUME=1 to continue from the latest epoch checkpoint in
# the output dir (save_strategy='epoch'). Safe on a fresh run (trains from
# scratch if no checkpoint exists).
# ============================================================================

set -euo pipefail

WORKDIR="/nfs/turbo/coe-chaijy-unreplicated/josuetf/LMPlayschool/playpen"
CONDA_ENV="playpen"
# Model to fine-tune. Override LEARNER + HF_BASE to train a different one.
#   default:  Qwen3.5-27B in 4-bit QLoRA.
#   bf16 2B:  LEARNER=Qwen3.5-2B-Instruct-bf16 \
#             HF_BASE=/nfs/turbo/coe-chaijy-unreplicated/pre-trained-weights/Qwen3.5-2B \
#             PRECISION=bf16 TRAIN_BATCH_SIZE=8 sbatch --gpus=1 run_sft.sh
# (Keep batch modest even for small models: the causal-LM loss materializes a
#  full-vocab logits tensor [batch x seq x ~152k], which dominates memory and
#  scales with batch regardless of model size — batch 16 OOMs a 46GB A40.)
LEARNER="${LEARNER:-Qwen3.5-27B-Instruct-4bit}"
HF_BASE="${HF_BASE:-/nfs/turbo/coe-chaijy-unreplicated/pre-trained-weights/Qwen3.5-27B}"
# Weights precision: 4bit (QLoRA, for big models on 46GB cards) or bf16 (no
# quantization + LoRA; right for small models like the 2B that fit comfortably).
PRECISION="${PRECISION:-4bit}"

# Which filtered route to train on (positive_score | non_aborted).
DATA_ROUTE="${DATA_ROUTE:-positive_score}"
DATA_DIR="${DATA_DIR:-/nfs/turbo/coe-chaijy-unreplicated/josuetf/LMPlayschool/scaling_LLM_search_methods/playpen-sft-data/sft-filtered/${DATA_ROUTE}}"

# Output tag: keeps THIS run's adapter in its own dir so a prior run is untouched.
RUN_TAG="${RUN_TAG:-${DATA_ROUTE}}"
RUN_NAME="${LEARNER}-${RUN_TAG}"          # e.g. Qwen3.5-27B-Instruct-4bit-positive_score
MODEL_OUT="${MODEL_OUT:-models/sft/${RUN_NAME}}"

# Training knobs.
MAX_LENGTH="${MAX_LENGTH:-1024}"          # tokens/example; longer convos truncated
# Run UNTIL CONVERGENCE: evaluate every epoch and early-stop when the val loss
# stops improving for EARLY_STOPPING_PATIENCE epochs; the best epoch is kept.
# MAX_EPOCHS is just a backstop cap — training almost always stops well before it.
MAX_EPOCHS="${MAX_EPOCHS:-50}"
EARLY_STOPPING_PATIENCE="${EARLY_STOPPING_PATIENCE:-5}"
LEARNING_RATE="${LEARNING_RATE:-2e-4}"    # standard QLoRA LR
# Per-device train batch. 4 fits a 27B 4-bit + LoRA on a 46GB A40 at max-length
# 1024 (the full-vocab logits for causal-LM loss are the memory driver; batch 8
# OOMs). grad-accum is AUTO-derived after topology detection so the effective
# batch stays constant (TRAIN_EFFECTIVE_BATCH) for any GPU/node count.
TRAIN_BATCH_SIZE="${TRAIN_BATCH_SIZE:-4}"
TRAIN_GRAD_ACCUM="${TRAIN_GRAD_ACCUM:-}"
TRAIN_EFFECTIVE_BATCH="${TRAIN_EFFECTIVE_BATCH:-128}"

# Weights & Biases logging. WANDB=0 disables it (report_to=none). WANDB_PROJECT
# groups runs; WANDB_RUN_NAME defaults to the run tag + job id. If no API key /
# credentials are found we drop to OFFLINE mode (logs to ./wandb, sync later with
# `wandb sync`) so a multi-day job never blocks or dies on a missing login.
WANDB="${WANDB:-1}"
WANDB_PROJECT="${WANDB_PROJECT:-playpen-sft}"
WANDB_RUN_NAME="${WANDB_RUN_NAME:-${RUN_NAME}-${SLURM_JOB_ID:-local}}"

cd "$WORKDIR"
mkdir -p logs slurm

# Activate conda
source "$(conda info --base)/etc/profile.d/conda.sh"
conda activate "$CONDA_ENV"

# Ignore ~/.local user-site packages. A stale/broken `wandb` lives there and
# user-site SHADOWS the conda env on sys.path, so without this every rank imports
# that broken wandb when TRL calls is_wandb_available() and dies with the
# protobuf "Descriptors cannot be created directly" error. Everything the trainer
# needs (torch/trl/transformers/peft/datasets/wandb) is in the env, so excluding
# user-site is safe and uses the env's healthy wandb 0.28.0.
export PYTHONNOUSERSITE=1

# --- W&B preflight: decide report backend + mode before launching ---------
REPORT_TO="none"
if [ "$WANDB" = "1" ]; then
    if python -c "import wandb" 2>/dev/null; then
        REPORT_TO="wandb"
        export WANDB_PROJECT
        [ -n "${WANDB_ENTITY:-}" ] && export WANDB_ENTITY
        # Pick a mode: honor an explicit WANDB_MODE; else online only if creds
        # exist (env key or ~/.netrc), otherwise offline so it can't block.
        if [ -z "${WANDB_MODE:-}" ]; then
            if [ -n "${WANDB_API_KEY:-}" ] || grep -q 'api.wandb.ai' "${HOME}/.netrc" 2>/dev/null; then
                export WANDB_MODE=online
            else
                export WANDB_MODE=offline
                echo "NOTE: no W&B credentials found -> WANDB_MODE=offline (logs to ./wandb;"
                echo "      run 'wandb login' then 'wandb sync wandb/offline-run-*' to upload)."
            fi
        else
            export WANDB_MODE
        fi
        echo "W&B:       project=$WANDB_PROJECT  run=$WANDB_RUN_NAME  mode=$WANDB_MODE"
    else
        echo "NOTE: WANDB=1 but the 'wandb' package isn't importable -> logging disabled."
    fi
fi

# Curb CUDA reserved-pool fragmentation so the high-water mark tracks live usage.
export PYTORCH_CUDA_ALLOC_CONF="${PYTORCH_CUDA_ALLOC_CONF:-expandable_segments:True}"

# ------------------------------------------------------------------
# Cluster topology — adapt to WHATEVER Slurm granted (1 node or many). DDP fans
# out over $WORLD_GPUS = $NNODES x $GPUS_PER_NODE. Multi-node reaches other nodes
# via srun (bash `&` can't); single node keeps the local fan-out. Outside Slurm
# -> 1 local node. (Same derivation as run_prm.sh.)
# ------------------------------------------------------------------
if [ -n "${SLURM_JOB_ID:-}" ]; then
    NNODES="${SLURM_NNODES:-1}"
    # Derive the TOTAL GPU count from scontrol (AllocTRES gres/gpu=N), not
    # SLURM_GPUS_ON_NODE — with `--gpus=N` (a per-JOB total) the latter is
    # unreliable (often 1), which silently under-uses GPUs and shrinks the
    # effective batch.
    total_gpus="$(scontrol show job "$SLURM_JOB_ID" 2>/dev/null \
                   | grep -oE 'gres/gpu=[0-9]+' | head -1 | grep -oE '[0-9]+')"
    [ -n "$total_gpus" ] || total_gpus="${SLURM_GPUS:-}"
    total_gpus="${total_gpus##*:}"   # "a40:8" -> "8"
    case "$total_gpus" in ''|*[!0-9]*) total_gpus=$(( ${SLURM_GPUS_ON_NODE:-$(nvidia-smi -L 2>/dev/null | wc -l)} * NNODES )) ;; esac
    GPUS_PER_NODE=$(( total_gpus / NNODES ))
    HEAD_NODE="$(scontrol show hostnames "${SLURM_JOB_NODELIST:-}" 2>/dev/null | head -1)"
else
    NNODES=1
    GPUS_PER_NODE="$(nvidia-smi -L 2>/dev/null | wc -l)"
    HEAD_NODE="$(hostname)"
fi
case "$GPUS_PER_NODE" in ''|*[!0-9]*) GPUS_PER_NODE=1 ;; esac
[ "$GPUS_PER_NODE" -ge 1 ] || GPUS_PER_NODE=1
[ -n "$HEAD_NODE" ] || HEAD_NODE="$(hostname)"
WORLD_GPUS=$(( NNODES * GPUS_PER_NODE ))
RDZV_PORT="${RDZV_PORT:-29501}"
if [ "$NNODES" -gt 1 ]; then MULTINODE=1; else MULTINODE=0; fi

# Multi-node: probe each node's ACTUAL allocated GPU count (same srun pattern the
# training launch uses) and sum them for the AUTHORITATIVE world size. This makes
# UNEVEN splits correct even when the total isn't divisible by NNODES (e.g. 5+3,
# or 5+2=7): the even-split GPUS_PER_NODE above would otherwise mis-derive
# WORLD_GPUS and skew the effective batch. torchrun still uses each node's own
# local count ($lg) below, so the per-node nproc is always exact.
if [ "$MULTINODE" -eq 1 ]; then
    _probe="$(srun --ntasks="$NNODES" --ntasks-per-node=1 --gpu-bind=none \
                 bash -c 'nvidia-smi -L 2>/dev/null | wc -l' 2>/dev/null || true)"
    _acc=0
    while read -r _cnt; do
        case "${_cnt:-}" in ''|*[!0-9]*) continue ;; esac
        _acc=$(( _acc + _cnt ))
    done <<< "$_probe"
    [ "$_acc" -ge 1 ] && WORLD_GPUS="$_acc"   # authoritative total across uneven nodes
fi

# Hold the effective batch constant across any GPU count:
#   effective = per_device_batch * WORLD_GPUS * grad_accum
if [ -z "$TRAIN_GRAD_ACCUM" ]; then
    TRAIN_GRAD_ACCUM=$(( TRAIN_EFFECTIVE_BATCH / (TRAIN_BATCH_SIZE * WORLD_GPUS) ))
    [ "$TRAIN_GRAD_ACCUM" -ge 1 ] || TRAIN_GRAD_ACCUM=1
fi

echo "=============================="
echo "Job ID:    ${SLURM_JOB_ID:-<direct>}"
echo "Node:      ${SLURMD_NODENAME:-$(hostname)}"
echo "GPUs:"
nvidia-smi --query-gpu=index,name,memory.total,memory.used,memory.free --format=csv
echo "Topology:  ${NNODES} node(s) x ${GPUS_PER_NODE} GPU = ${WORLD_GPUS} GPUs  (multinode=${MULTINODE}, head=${HEAD_NODE})"
echo "Data:      $DATA_DIR  (route=$DATA_ROUTE)"
echo "Model:     $LEARNER  ($PRECISION)  <- $HF_BASE"
echo "Output:    $MODEL_OUT"
echo "Train:     per_device=${TRAIN_BATCH_SIZE} x world=${WORLD_GPUS} x grad_accum=${TRAIN_GRAD_ACCUM} = $(( TRAIN_BATCH_SIZE * WORLD_GPUS * TRAIN_GRAD_ACCUM )) effective batch"
echo "           max_length=${MAX_LENGTH}  max_epochs=${MAX_EPOCHS} (early-stop patience=${EARLY_STOPPING_PATIENCE})  lr=${LEARNING_RATE}"
echo "Started:   $(date)"
echo "=============================="

[ -d "$DATA_DIR/train" ] || { echo "ERROR: no train/ split at $DATA_DIR"; exit 1; }

# ------------------------------------------------------------------
# SFT training — DATA-PARALLEL (DDP) across the WHOLE allocation. Every GPU holds
# a full 4-bit copy and trains on a different data shard. Effective batch is held
# at TRAIN_EFFECTIVE_BATCH by the auto-derived grad_accum, so the optimization is
# identical no matter how many GPUs/nodes Slurm granted.
# ------------------------------------------------------------------
train_args=(
    --data-dir "$DATA_DIR"
    --model "$HF_BASE"
    --output "$MODEL_OUT"
    --per-device-batch-size "$TRAIN_BATCH_SIZE"
    --gradient-accumulation-steps "$TRAIN_GRAD_ACCUM"
    --max-length "$MAX_LENGTH"
    --max-epochs "$MAX_EPOCHS"
    --early-stopping-patience "$EARLY_STOPPING_PATIENCE"
    --learning-rate "$LEARNING_RATE"
    --report-to "$REPORT_TO"
    --run-name "$WANDB_RUN_NAME"
)
# bf16 precision -> load unquantized + LoRA (no 4-bit). Right for small models.
[ "$PRECISION" = "bf16" ] && train_args+=(--no-4bit)
# Fast smoke test: LIMIT_TRAIN_SAMPLES=256 MAX_EPOCHS=1 sbatch --gpus=1 ... run_sft.sh
[ -n "${LIMIT_TRAIN_SAMPLES:-}" ] && train_args+=(--limit-train-samples "$LIMIT_TRAIN_SAMPLES")
[ "${RESUME:-0}" = "1" ] && train_args+=(--resume)

echo ""
echo "=== SFT Training: QLoRA (4-bit + LoRA) as DDP across $WORLD_GPUS GPU(s) on $NNODES node(s) ==="
# Per-RUN log so concurrent SFT runs (e.g. 27B + 2B) don't clobber each other's
# output. sft_progress.sh finds it from this run's Output dir.
TRAIN_LOG="logs/sft_${RUN_NAME}.log"
echo "Train log: $TRAIN_LOG"
train_fail=0
if [ "$MULTINODE" -eq 1 ]; then
    # One agent per node (srun -> 1 task/node, --gpu-bind=none so the task sees
    # ALL that node's GPUs). Each node runs torchrun with ITS OWN local GPU count
    # (nvidia-smi), so an uneven split (e.g. 5+3) still rendezvous-sums to the
    # global world size. Training args after `-c bash` arrive as "$@".
    srun --ntasks="$NNODES" --ntasks-per-node=1 --gpu-bind=none \
        bash -c 'lg=$(nvidia-smi -L 2>/dev/null | wc -l); [ "$lg" -ge 1 ] || lg=1
                 exec torchrun --nnodes='"$NNODES"' --nproc-per-node="$lg" \
                      --rdzv-backend=c10d --rdzv-id='"$SLURM_JOB_ID"' \
                      --rdzv-endpoint='"$HEAD_NODE:$RDZV_PORT"' \
                      examples/trl/sft_train_from_filtered.py "$@"' \
        bash "${train_args[@]}" \
        > "$TRAIN_LOG" 2>&1 || train_fail=1
elif [ "$WORLD_GPUS" -gt 1 ]; then
    # Single node, multiple GPUs: standalone DDP.
    torchrun --standalone --nnodes=1 --nproc-per-node="$GPUS_PER_NODE" \
             examples/trl/sft_train_from_filtered.py "${train_args[@]}" \
        > "$TRAIN_LOG" 2>&1 || train_fail=1
else
    python examples/trl/sft_train_from_filtered.py "${train_args[@]}" \
        > "$TRAIN_LOG" 2>&1 || train_fail=1
fi

if [ "$train_fail" -ne 0 ]; then
    echo "  SFT training: FAILED (see $TRAIN_LOG)"
    tail -n 30 "$TRAIN_LOG" 2>/dev/null | sed 's/^/    /' || true
    exit 1
fi

echo "  SFT training: OK"
echo ""
echo "Training finished at: $(date)"
echo "Adapter saved to:     $MODEL_OUT"
echo "=============================="
echo "Done: $(date)"
echo "=============================="