gpudrive-main/scripts/search_longtail_reward_conditioned.sbatch

#!/bin/bash
#SBATCH --partition=gre
#SBATCH --nodes=1
#SBATCH --ntasks=1
#SBATCH --gres=gpu:4
#SBATCH --time=48:00:00
#SBATCH --job-name=lzh_longtail_search
#SBATCH --output=%x-%j.out
#SBATCH --mem=256G
#SBATCH --cpus-per-task=32

set -euo pipefail

PROJECT_ROOT="${PROJECT_ROOT:-/mingli01/project/zihanliu/gpudrive-main}"
CONDA_ENV_NAME="${CONDA_ENV_NAME:-gpudrive}"
CONFIG_PATH="${CONFIG_PATH:-baselines/ppo/config/ppo_mini_reward_conditioned.yaml}"
CHECKPOINT="${CHECKPOINT:-}"
DATA_DIR="${DATA_DIR:-/mingli01/data/GPUDrive_mini/training}"
OUTPUT_DIR="${OUTPUT_DIR:-longtail_outputs/reward_conditioned_search}"

NUM_GPUS="${NUM_GPUS:-4}"
NUM_WORLDS="${NUM_WORLDS:-1000}"
DATASET_SIZE="${DATASET_SIZE:-864}"
NUM_BATCHES="${NUM_BATCHES:-10}"
STEPS="${STEPS:-91}"
SEED="${SEED:-42}"
DETERMINISTIC="${DETERMINISTIC:-0}"
RISK_AGENTS_PER_WORLD="${RISK_AGENTS_PER_WORLD:-3}"
NORMAL_MODE="${NORMAL_MODE:-policy}"
NORMAL_STYLE="${NORMAL_STYLE:-balanced}"
RISK_STYLE="${RISK_STYLE:-risk_taker}"
RISK_COLLISION_WEIGHT="${RISK_COLLISION_WEIGHT:-0.0}"
RISK_GOAL_WEIGHT="${RISK_GOAL_WEIGHT:-2.0}"
RISK_OFFROAD_WEIGHT="${RISK_OFFROAD_WEIGHT:--0.4}"
NEAR_MISS_THRESHOLD_M="${NEAR_MISS_THRESHOLD_M:-2.0}"
SAVE_OFFROAD="${SAVE_OFFROAD:-0}"
OBS_RADIUS="${OBS_RADIUS:-}"
POLYLINE_REDUCTION_THRESHOLD="${POLYLINE_REDUCTION_THRESHOLD:-}"
SUMMARY_TOP_K="${SUMMARY_TOP_K:-100}"
SAVE_EVENT_TRACES="${SAVE_EVENT_TRACES:-1}"
TRACE_PRE_STEPS="${TRACE_PRE_STEPS:-50}"
TRACE_POST_STEPS="${TRACE_POST_STEPS:-10}"
TRACE_INCLUDE_ALL_AGENTS="${TRACE_INCLUDE_ALL_AGENTS:-1}"
TRACE_TOP_K_AGENTS="${TRACE_TOP_K_AGENTS:-16}"
TRACE_MAP_RADIUS_M="${TRACE_MAP_RADIUS_M:-80.0}"
TRACE_MAP_TOP_K="${TRACE_MAP_TOP_K:-256}"
TRACE_DT="${TRACE_DT:-0.1}"

module load conda/3
source "$(conda info --base)/etc/profile.d/conda.sh"
conda activate "${CONDA_ENV_NAME}"

export PYTHONNOUSERSITE=1
export PYTHONUNBUFFERED=1
export OMP_NUM_THREADS="${OMP_NUM_THREADS:-1}"
export MKL_NUM_THREADS="${MKL_NUM_THREADS:-1}"
export MADRONA_MWGPU_KERNEL_CACHE="${MADRONA_MWGPU_KERNEL_CACHE:-${PROJECT_ROOT}/gpudrive_cache}"

cd "${PROJECT_ROOT}"
export PYTHONPATH="${PROJECT_ROOT}:${PYTHONPATH:-}"

if [[ ! -f "${CONFIG_PATH}" ]]; then
  echo "ERROR: config not found: ${CONFIG_PATH}"
  exit 1
fi

if [[ ! -d "${DATA_DIR}" ]]; then
  echo "ERROR: DATA_DIR does not exist: ${DATA_DIR}"
  exit 1
fi

if ! compgen -G "${DATA_DIR}/tfrecord*.json" >/dev/null; then
  echo "ERROR: no tfrecord*.json files found under DATA_DIR=${DATA_DIR}"
  exit 1
fi

mkdir -p "${OUTPUT_DIR}/logs"

echo "SLURM_JOB_ID=${SLURM_JOB_ID:-unknown}"
echo "PROJECT_ROOT=${PROJECT_ROOT}"
echo "CONFIG_PATH=${CONFIG_PATH}"
echo "CHECKPOINT=${CHECKPOINT:-auto-latest}"
echo "DATA_DIR=${DATA_DIR}"
echo "OUTPUT_DIR=${OUTPUT_DIR}"
echo "NUM_GPUS=${NUM_GPUS}"
echo "NUM_WORLDS=${NUM_WORLDS}"
echo "DATASET_SIZE=${DATASET_SIZE}"
echo "NUM_BATCHES=${NUM_BATCHES}"
echo "STEPS=${STEPS}"
echo "RISK_AGENTS_PER_WORLD=${RISK_AGENTS_PER_WORLD}"
echo "NORMAL_MODE=${NORMAL_MODE}"
echo "RISK_COLLISION_WEIGHT=${RISK_COLLISION_WEIGHT}"
echo "RISK_GOAL_WEIGHT=${RISK_GOAL_WEIGHT}"
echo "RISK_OFFROAD_WEIGHT=${RISK_OFFROAD_WEIGHT}"
echo "NEAR_MISS_THRESHOLD_M=${NEAR_MISS_THRESHOLD_M}"
echo "SAVE_EVENT_TRACES=${SAVE_EVENT_TRACES}"
echo "TRACE_PRE_STEPS=${TRACE_PRE_STEPS}"
echo "TRACE_POST_STEPS=${TRACE_POST_STEPS}"
echo "TRACE_INCLUDE_ALL_AGENTS=${TRACE_INCLUDE_ALL_AGENTS}"
echo "TRACE_MAP_RADIUS_M=${TRACE_MAP_RADIUS_M}"
echo "CUDA_VISIBLE_DEVICES=${CUDA_VISIBLE_DEVICES:-unset}"

if command -v nvidia-smi >/dev/null 2>&1; then
  nvidia-smi -L || true
fi

IFS=',' read -r -a GPU_IDS <<< "${CUDA_VISIBLE_DEVICES:-0,1,2,3}"

for SHARD_ID in $(seq 0 $((NUM_GPUS - 1))); do
  GPU_ID="${GPU_IDS[$SHARD_ID]:-${SHARD_ID}}"
  CMD=(
    python -u scripts/search_longtail_reward_conditioned.py
    --config "${CONFIG_PATH}"
    --data-dir "${DATA_DIR}"
    --output-dir "${OUTPUT_DIR}"
    --num-worlds "${NUM_WORLDS}"
    --dataset-size "${DATASET_SIZE}"
    --num-batches "${NUM_BATCHES}"
    --steps "${STEPS}"
    --seed "${SEED}"
    --shard-id "${SHARD_ID}"
    --num-shards "${NUM_GPUS}"
    --deterministic "${DETERMINISTIC}"
    --risk-agents-per-world "${RISK_AGENTS_PER_WORLD}"
    --normal-mode "${NORMAL_MODE}"
    --normal-style "${NORMAL_STYLE}"
    --risk-style "${RISK_STYLE}"
    --risk-collision-weight "${RISK_COLLISION_WEIGHT}"
    --risk-goal-weight "${RISK_GOAL_WEIGHT}"
    --risk-offroad-weight "${RISK_OFFROAD_WEIGHT}"
    --near-miss-threshold-m "${NEAR_MISS_THRESHOLD_M}"
    --save-offroad "${SAVE_OFFROAD}"
    --save-event-traces "${SAVE_EVENT_TRACES}"
    --trace-pre-steps "${TRACE_PRE_STEPS}"
    --trace-post-steps "${TRACE_POST_STEPS}"
    --trace-include-all-agents "${TRACE_INCLUDE_ALL_AGENTS}"
    --trace-top-k-agents "${TRACE_TOP_K_AGENTS}"
    --trace-map-radius-m "${TRACE_MAP_RADIUS_M}"
    --trace-map-top-k "${TRACE_MAP_TOP_K}"
    --trace-dt "${TRACE_DT}"
  )

  if [[ -n "${CHECKPOINT}" ]]; then
    CMD+=(--checkpoint "${CHECKPOINT}")
  fi
  if [[ -n "${OBS_RADIUS}" ]]; then
    CMD+=(--obs-radius "${OBS_RADIUS}")
  fi
  if [[ -n "${POLYLINE_REDUCTION_THRESHOLD}" ]]; then
    CMD+=(--polyline-reduction-threshold "${POLYLINE_REDUCTION_THRESHOLD}")
  fi

  echo "Launching shard ${SHARD_ID} on CUDA_VISIBLE_DEVICES=${GPU_ID}: ${CMD[*]}"
  CUDA_VISIBLE_DEVICES="${GPU_ID}" "${CMD[@]}" \
    > "${OUTPUT_DIR}/logs/shard_${SHARD_ID}.out" \
    2> "${OUTPUT_DIR}/logs/shard_${SHARD_ID}.err" &
done

wait

echo "All shards finished. Summaries:"
find "${OUTPUT_DIR}" -path "*/summary.json" -print

echo "Shard progress logs:"
find "${OUTPUT_DIR}/logs" -name "shard_*.out" -print

python -u scripts/summarize_longtail_search.py \
  --search-dir "${OUTPUT_DIR}" \
  --top-k "${SUMMARY_TOP_K}"