shell/launch_train_spatial_af3_qa.sh

#!/usr/bin/env bash
# AF3 + Spatial-BEATs 的 Spatial-QA 训练脚本（基于 launch_train_spatial_beats_v13d_easy.sh）
#
# 数据：与 Spatial-Qwen 同（--qa-root 指向 easy_filtered / medium 等）
# 基座：nvidia/audio-flamingo-3-hf（本地 HF cache 路径）
# Encoder：Spatial-BEATs v11a（10 Hz → 2.5 Hz via pixel_shuffle×4）
#
# 与 Qwen 路径的主要区别：
#   1) 使用 AF3 而非 Qwen2.5-Omni（无 Thinker/Talker 拆分）
#   2) LoRA 目标前缀 = language_model.model（非 thinker.model）
#   3) 占位符为 <sound>/<spatial>（不是 <|AUDIO|>/<|spatial|>）
#   4) 依赖本地 transformers fork（NVIDIA/Qwen 官方版没有 AF3 类）
#
# 环境要求（在训练前 confirm）：
#   - transformers fork 路径包含 AudioFlamingo3 类：
#     /apdcephfs_cq10/.../model/transformers/src
#   - 该 fork 的 transformers 版本为 5.0.0rc1，与 Spatial-Qwen 用的 4.52.0 不兼容；
#     因此**建议创建独立的 conda env**：
#       conda create -n af3 python=3.10
#       conda activate af3
#       cd /apdcephfs_cq10/.../model/transformers && pip install -e .
#       pip install peft torch numpy soundfile tensorboard tqdm
#
# 使用示例：
#   # 单机 8 卡完整 2 阶段
#   bash shell/launch_train_spatial_af3_qa.sh
#   # 从 stage2 开始
#   START_STAGE=2 bash shell/launch_train_spatial_af3_qa.sh
#   # 单机 4 卡
#   GPUS=0,1,2,3 bash shell/launch_train_spatial_af3_qa.sh
#   # 3 stage（解冻 BEATs）：
#   START_STAGE=3 bash shell/launch_train_spatial_af3_qa.sh

set -euo pipefail

ROOT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")"/.. && pwd)"

# ------------------------------------------------------------------
# 分布式 / GPU
# ------------------------------------------------------------------
GPUS="${GPUS:-0,1,2,3,4,5,6,7}"
NPROC="${NPROC:-$(python -c 'import sys; print(len([x for x in sys.argv[1].split(",") if x]))' "${GPUS}")}"
NNODES="${NNODES:-1}"
NODE_RANK="${NODE_RANK:-0}"
MASTER_ADDR="${MASTER_ADDR:-127.0.0.1}"
MASTER_PORT="${MASTER_PORT:-29577}"
START_STAGE="${START_STAGE:-1}"

if (( NNODES > 1 )) && [[ "${MASTER_ADDR}" == "127.0.0.1" || "${MASTER_ADDR}" == "localhost" ]]; then
  echo "[ERROR] NNODES=${NNODES} > 1 but MASTER_ADDR is loopback (${MASTER_ADDR})." >&2
  echo "        Set MASTER_ADDR to the actual IP of rank-0 machine." >&2
  exit 1
fi

# ------------------------------------------------------------------
# 模型 / 依赖路径
# ------------------------------------------------------------------
# AF3 本地 HF snapshot（含 config.json / model.safetensors / processor）
AF3_MODEL_ID="${AF3_MODEL_ID:-/apdcephfs_cq10/share_1603164/user/schmittzhu/model/hf_cache/hub/models--nvidia--audio-flamingo-3-hf/snapshots/7d4bae64ee29878af6504ae6f6bb3e40492838ad}"

# 本地 transformers fork，含 models/audioflamingo3
AF3_TRANSFORMERS_FORK="${AF3_TRANSFORMERS_FORK:-/apdcephfs_cq10/share_1603164/user/schmittzhu/model/transformers/src}"

# Spatial-BEATs 预训练 ckpt 和仓库（与 Spatial-Qwen 相同）
BEATS_CKPT="${BEATS_CKPT:-/apdcephfs_cq10/share_1603164/user/schmittzhu/code/unilm/beats/checkpoints/spatial_beats_ov1_unified_v13d_exp/03_ov123_top4/best.pt}"
BEATS_REPO="${BEATS_REPO:-/apdcephfs_cq10/share_1603164/user/schmittzhu/code/unilm/beats}"

# ------------------------------------------------------------------
# 数据
# ------------------------------------------------------------------
QA_ROOT="${QA_ROOT:-/apdcephfs_cq10/share_1603164/user/schmittzhu/data/process_data/genQA/all_qa_llm_by_difficulty_v2/easy_filtered}"

# ------------------------------------------------------------------
# 输出目录（默认与 Qwen 路径完全隔离）
# ------------------------------------------------------------------
RUN_ROOT="${RUN_ROOT:-${ROOT_DIR}/runs/v13d_medium_plus_easy10_llmqa_af3_from_easy}"
STAGE1_DIR="${STAGE1_DIR:-${RUN_ROOT}/stage1_projector}"
STAGE2_DIR="${STAGE2_DIR:-${RUN_ROOT}/stage2_encoder_lora}"
STAGE3_DIR="${STAGE3_DIR:-${RUN_ROOT}/stage3_beats_lora}"

STAGE2_RESUME_CKPT="${STAGE2_RESUME_CKPT:-${STAGE1_DIR}/checkpoints/best_trainable.pt}"
STAGE3_RESUME_CKPT="${STAGE3_RESUME_CKPT:-${STAGE2_DIR}/checkpoints/best_trainable.pt}"

# ------------------------------------------------------------------
# batch / DataLoader / 频率
# ------------------------------------------------------------------
BATCH_SIZE="${BATCH_SIZE:-2}"
GRAD_ACCUM_STEPS="${GRAD_ACCUM_STEPS:-3}"
NUM_WORKERS="${NUM_WORKERS:-8}"
PREFETCH_FACTOR="${PREFETCH_FACTOR:-4}"
SAVE_EVERY_N_OPT_STEPS="${SAVE_EVERY_N_OPT_STEPS:-1000}"
VALID_EVERY_N_OPT_STEPS="${VALID_EVERY_N_OPT_STEPS:-1000}"

ATTN_IMPL="${ATTN_IMPL:-sdpa}"
USE_GRADIENT_CHECKPOINTING="${USE_GRADIENT_CHECKPOINTING:-0}"
MAX_GRAD_NORM="${MAX_GRAD_NORM:-1.0}"

# ------------------------------------------------------------------
# 训练 schedule（与 Spatial-Qwen BEATs 路径对齐）
# ------------------------------------------------------------------
STAGE1_EPOCHS="${STAGE1_EPOCHS:-2}"
STAGE2_EPOCHS="${STAGE2_EPOCHS:-3}"
STAGE3_EPOCHS="${STAGE3_EPOCHS:-3}"

STAGE1_LR="${STAGE1_LR:-5e-5}"
STAGE1_PROJECTOR_LR="${STAGE1_PROJECTOR_LR:-5e-5}"

STAGE2_LR="${STAGE2_LR:-3e-5}"
STAGE2_LORA_LR="${STAGE2_LORA_LR:-3e-5}"
STAGE2_PROJECTOR_LR="${STAGE2_PROJECTOR_LR:-1e-5}"

STAGE3_LR="${STAGE3_LR:-1e-5}"
STAGE3_LORA_LR="${STAGE3_LORA_LR:-1e-5}"
STAGE3_PROJECTOR_LR="${STAGE3_PROJECTOR_LR:-5e-6}"
STAGE3_BEATS_LR="${STAGE3_BEATS_LR:-1e-6}"

# ------------------------------------------------------------------
# LoRA
# ------------------------------------------------------------------
LORA_R="${LORA_R:-16}"
LORA_ALPHA="${LORA_ALPHA:-32}"
LORA_DROPOUT="${LORA_DROPOUT:-0.05}"
LORA_TARGET_MODULES=(${LORA_TARGET_MODULES:-q_proj k_proj v_proj o_proj})

# ------------------------------------------------------------------
# 前置检查
# ------------------------------------------------------------------
if [[ ! -d "${AF3_MODEL_ID}" ]]; then
  echo "Missing AF3 snapshot dir: ${AF3_MODEL_ID}" >&2; exit 1
fi
if [[ ! -d "${AF3_TRANSFORMERS_FORK}" ]]; then
  echo "Missing transformers fork: ${AF3_TRANSFORMERS_FORK}" >&2; exit 1
fi
if [[ ! -f "${BEATS_CKPT}" ]]; then
  echo "Missing BEATs checkpoint: ${BEATS_CKPT}" >&2; exit 1
fi
if [[ ! -d "${QA_ROOT}" ]]; then
  echo "Missing QA root: ${QA_ROOT}" >&2; exit 1
fi
for split in train valid test; do
  if [[ ! -f "${QA_ROOT}/${split}.jsonl" ]]; then
    echo "Missing ${QA_ROOT}/${split}.jsonl" >&2; exit 1
  fi
done

# Ensure the AF3 fork takes precedence over any site-packages transformers
export PYTHONPATH="${AF3_TRANSFORMERS_FORK}:${PYTHONPATH:-}"

# Reduce CUDA memory fragmentation. The default allocator pre-allocates
# fixed-size segments and can fail to satisfy a large allocation even when
# total free memory > requested size, especially in long-running multi-stage
# training with variable seq_lens. expandable_segments grows allocations
# dynamically, fixing most "X MiB free but tried to allocate Y MiB" OOMs.
export PYTORCH_CUDA_ALLOC_CONF="${PYTORCH_CUDA_ALLOC_CONF:-expandable_segments:True}"

echo "==========================================================="
echo " AF3 + Spatial-BEATs training"
echo "   AF3_MODEL_ID=${AF3_MODEL_ID}"
echo "   AF3_TRANSFORMERS_FORK=${AF3_TRANSFORMERS_FORK}"
echo "   BEATS_CKPT=${BEATS_CKPT}"
echo "   NNODES=${NNODES} NODE_RANK=${NODE_RANK} NPROC=${NPROC}"
echo "   RUN_ROOT=${RUN_ROOT}  START_STAGE=${START_STAGE}"
echo "==========================================================="

run_train() {
  CUDA_VISIBLE_DEVICES="${GPUS}" torchrun \
      --nnodes="${NNODES}" \
      --node_rank="${NODE_RANK}" \
      --nproc_per_node="${NPROC}" \
      --master_addr="${MASTER_ADDR}" \
      --master_port="${MASTER_PORT}" \
      "${ROOT_DIR}/train_spatial_af3_qa.py" "$@"
}

common_args=(
  --model-id "${AF3_MODEL_ID}"
  --af3-transformers-fork "${AF3_TRANSFORMERS_FORK}"
  --beats-checkpoint "${BEATS_CKPT}"
  --beats-repo "${BEATS_REPO}"
  --qa-root "${QA_ROOT}"
  --train-split train
  --valid-split valid
  --device cuda:0
  --dtype bfloat16
  --attn-impl "${ATTN_IMPL}"
  --batch-size "${BATCH_SIZE}"
  --grad-accum-steps "${GRAD_ACCUM_STEPS}"
  --num-workers "${NUM_WORKERS}"
  --persistent-workers
  --prefetch-factor "${PREFETCH_FACTOR}"
  --warmup-ratio 0.03
  --weight-decay 0.01
  --max-grad-norm "${MAX_GRAD_NORM}"
  --save-every-epoch
  --save-every-n-optimizer-steps "${SAVE_EVERY_N_OPT_STEPS}"
  --valid-every-n-optimizer-steps "${VALID_EVERY_N_OPT_STEPS}"
  --valid-generate-max-samples "${VALID_GENERATE_MAX_SAMPLES:-32}"
  --valid-max-new-tokens 96
  --valid-num-beams 1
  --lora-r "${LORA_R}"
  --lora-alpha "${LORA_ALPHA}"
  --lora-dropout "${LORA_DROPOUT}"
  --lora-target-modules "${LORA_TARGET_MODULES[@]}"
  --lora-target-prefixes language_model.model
  --projector-type pixel_shuffle
  --projector-shuffle-factor 4
  --encoder-token-rate 10.0
)
if (( USE_GRADIENT_CHECKPOINTING == 1 )); then
  common_args+=(--gradient-checkpointing)
  echo "[config] gradient_checkpointing = ENABLED (--gradient-checkpointing flag passed; trades ~30% time for ~50% memory)"
else
  echo "[config] gradient_checkpointing = DISABLED (set USE_GRADIENT_CHECKPOINTING=1 to enable)"
fi
if [[ "${VALID_GENERATE_FULL:-0}" == "1" ]]; then
  common_args+=(--valid-generate-full)
fi
echo "[config] BATCH_SIZE=${BATCH_SIZE} GRAD_ACCUM_STEPS=${GRAD_ACCUM_STEPS} MAX_GRAD_NORM=${MAX_GRAD_NORM}"
echo "[config] ATTN_IMPL=${ATTN_IMPL}"

# ------------------------------------------------------------------
# Stage 1: projector_only
# ------------------------------------------------------------------
if (( START_STAGE <= 1 )); then
  echo "===== [stage1] projector_only (${STAGE1_EPOCHS} epochs, lr=${STAGE1_LR}) ====="
  echo "  → ${STAGE1_DIR}"
  run_train \
    "${common_args[@]}" \
    --projector-only \
    --lr "${STAGE1_LR}" \
    --projector-lr "${STAGE1_PROJECTOR_LR}" \
    --epochs "${STAGE1_EPOCHS}" \
    --output-dir "${STAGE1_DIR}"
fi

# ------------------------------------------------------------------
# Stage 2: encoder_lora
# ------------------------------------------------------------------
if (( START_STAGE <= 2 )); then
  if [[ ! -f "${STAGE2_RESUME_CKPT}" ]]; then
    echo "Missing stage2 resume checkpoint: ${STAGE2_RESUME_CKPT}" >&2
    echo "Set START_STAGE=1 to produce it, or STAGE2_RESUME_CKPT=/path/to/best_trainable.pt." >&2
    exit 1
  fi
  echo "===== [stage2] encoder_lora (${STAGE2_EPOCHS} epochs) ====="
  echo "  resume from: ${STAGE2_RESUME_CKPT}"
  echo "  → ${STAGE2_DIR}"
  run_train \
    "${common_args[@]}" \
    --encoder-lora \
    --resume-checkpoint-path "${STAGE2_RESUME_CKPT}" \
    --resume-model-only \
    --lr "${STAGE2_LR}" \
    --lora-lr "${STAGE2_LORA_LR}" \
    --projector-lr "${STAGE2_PROJECTOR_LR}" \
    --epochs "${STAGE2_EPOCHS}" \
    --output-dir "${STAGE2_DIR}"
fi

# ------------------------------------------------------------------
# Stage 3 (optional): beats_lora
# ------------------------------------------------------------------
if (( START_STAGE <= 3 )); then
  if [[ ! -f "${STAGE3_RESUME_CKPT}" ]]; then
    echo "Missing stage3 resume checkpoint: ${STAGE3_RESUME_CKPT}" >&2
    echo "Set RUN_STAGE3=0 or produce it via stage2, or STAGE3_RESUME_CKPT=/path/to/best_trainable.pt." >&2
    exit 1
  fi
  # STAGE3_RESUME_MODEL_ONLY:
  #   1 (default): fresh optimizer/scheduler, restart epoch 1. Use this when
  #                resuming from stage2 best (the canonical stage3 entry).
  #   0: keep optimizer/scheduler/step counter — use only when resuming from
  #     a mid-stage3 step ckpt to avoid re-warming up and re-running cosine.
  STAGE3_RESUME_MODEL_ONLY="${STAGE3_RESUME_MODEL_ONLY:-1}"
  stage3_extra=()
  if [[ "${STAGE3_RESUME_MODEL_ONLY}" == "1" ]]; then
    stage3_extra+=(--resume-model-only)
    echo "  resume mode: MODEL ONLY (fresh optimizer, restart from epoch 1)"
  else
    echo "  resume mode: FULL (optimizer + scheduler + step counter restored)"
  fi
  echo "===== [stage3] beats_lora (${STAGE3_EPOCHS} epochs) ====="
  echo "  resume from: ${STAGE3_RESUME_CKPT}"
  echo "  → ${STAGE3_DIR}"
  run_train \
    "${common_args[@]}" \
    --beats-lora \
    --resume-checkpoint-path "${STAGE3_RESUME_CKPT}" \
    "${stage3_extra[@]}" \
    --lr "${STAGE3_LR}" \
    --lora-lr "${STAGE3_LORA_LR}" \
    --projector-lr "${STAGE3_PROJECTOR_LR}" \
    --beats-lr "${STAGE3_BEATS_LR}" \
    --epochs "${STAGE3_EPOCHS}" \
    --output-dir "${STAGE3_DIR}"
fi

echo "All requested stages finished. Run dir = ${RUN_ROOT}"