scripts/train_spatial_qa.py

import argparse
import inspect
import json
import math
import os
import sys
import time
from collections import OrderedDict
from contextlib import nullcontext
from dataclasses import dataclass
from typing import Any, Dict, List, Optional, Tuple

import numpy as np
import soundfile as sf
import torch
import torch.distributed as dist
from torch.nn.parallel import DistributedDataParallel as DDP
from torch.utils.tensorboard import SummaryWriter
from torch.utils.data import ConcatDataset, DataLoader, Dataset, Subset
from torch.utils.data.distributed import DistributedSampler
from tqdm.auto import tqdm

try:
    from peft import LoraConfig, TaskType, get_peft_model
except ImportError:
    LoraConfig = None
    TaskType = None
    get_peft_model = None


DEFAULT_SPUR_REPO = None  # No longer needed; spatial_qwen package is used directly
DEFAULT_MODEL_ID = "/apdcephfs_cq10/share_1603164/user/schmittzhu/model/Qwen2.5-Omni-7B"
DEFAULT_QA_DATASET_ROOT = (
    "/apdcephfs_cq10/share_1603164/user/schmittzhu/code/DCASE2024_seld_baseline/"
    "prepared_datasets/starss23_foa_plus_29cls_20s"
)
DEFAULT_QA_ROOT = (
    f"{DEFAULT_QA_DATASET_ROOT}/qa_pairs_supported"
)
DEFAULT_QA_VERSION = "supported"
QA_VERSION_TO_SUBDIR = {
    "supported": "qa_pairs_supported",
    "new": "qa_pairs",
    "v2": "qa_pairs_v2",
    "v3": "qa_pairs_v3",
    "v4": "qa_pairs_v4",
    "v5": "qa_pairs_v5",
    "v5c": "qa_pairs_v5c",
    "v6c": "qa_pairs_v6c",
}
DEFAULT_SELD233_CKPT = (
    "/apdcephfs_cq10/share_1603164/user/schmittzhu/code/DCASE2024_seld_baseline/"
    "3_1_dev_split0_multiaccdoa_foa_model.h5"
)
DEFAULT_SELD233_STATS_DIR = (
    "/apdcephfs_cq10/share_1603164/user/schmittzhu/data/seld_feat_label/starss23_plus_foa_16k_29cls"
)
DEFAULT_OUTPUT_DIR = (
    "/apdcephfs_cq10/share_1603164/user/schmittzhu/code/DCASE2024_seld_baseline/"
    "spatial_qa_runs/default_run"
)
SAMPLE_RATE = 16000
MAX_AUDIO_SECONDS = 20
MAX_AUDIO_SAMPLES = SAMPLE_RATE * MAX_AUDIO_SECONDS
DEFAULT_LORA_TARGET_MODULES = (
    "q_proj",
    "k_proj",
    "v_proj",
    "o_proj",
    "gate_proj",
    "up_proj",
    "down_proj",
)


def parse_args() -> argparse.Namespace:
    parser = argparse.ArgumentParser(description="Train the Qwen spatial QA model on FOA + QA json/jsonl data.")
    parser.add_argument("--spur-repo-path", type=str, default=DEFAULT_SPUR_REPO)
    parser.add_argument("--model-id", type=str, default=DEFAULT_MODEL_ID)
    parser.add_argument(
        "--qa-root",
        type=str,
        default=None,
        help="Explicit QA directory containing train/valid/test json or jsonl files. Overrides --qa-version.",
    )
    parser.add_argument(
        "--qa-roots",
        nargs="+",
        default=None,
        help="Multiple QA directories to concatenate for joint training/validation. Overrides --qa-root and --qa-version.",
    )
    parser.add_argument(
        "--qa-version",
        type=str,
        default=DEFAULT_QA_VERSION,
        choices=sorted(QA_VERSION_TO_SUBDIR.keys()),
        help="Named QA dataset version under the prepared_datasets root.",
    )
    parser.add_argument("--train-split", type=str, default="train")
    parser.add_argument("--valid-split", type=str, default="valid")
    parser.add_argument("--max-train-samples", type=int, default=None)
    parser.add_argument("--max-valid-samples", type=int, default=None)
    parser.add_argument("--valid-subset-ratio", type=float, default=0.1)
    parser.add_argument("--batch-size", type=int, default=1)
    parser.add_argument("--grad-accum-steps", type=int, default=1)
    parser.add_argument("--num-workers", type=int, default=0)
    parser.add_argument(
        "--persistent-workers",
        action="store_true",
        help="Keep DataLoader workers alive across epochs when num_workers > 0.",
    )
    parser.add_argument(
        "--prefetch-factor",
        type=int,
        default=2,
        help="DataLoader prefetch_factor used when num_workers > 0.",
    )
    parser.add_argument(
        "--feature-cache-max-entries",
        type=int,
        default=32,
        help="Maximum number of cached seld233 feature tensors kept in memory per collator process. Set <= 0 to disable in-memory caching.",
    )
    parser.add_argument(
        "--hidden-cache-max-entries",
        type=int,
        default=128,
        help="Maximum number of cached seld233 hidden tensors kept in memory per collator process. Set <= 0 to disable in-memory caching.",
    )
    parser.add_argument("--epochs", type=int, default=1)
    parser.add_argument("--lr", type=float, default=1e-5)
    parser.add_argument("--weight-decay", type=float, default=0.01)
    parser.add_argument("--warmup-ratio", type=float, default=0.03)
    parser.add_argument("--max-grad-norm", type=float, default=1.0)
    parser.add_argument("--log-every", type=int, default=10)
    parser.add_argument("--seed", type=int, default=1234)
    parser.add_argument("--device", type=str, default="cuda:0")
    parser.add_argument("--local-rank", type=int, default=-1)
    parser.add_argument(
        "--dtype",
        type=str,
        default="bfloat16",
        choices=("float32", "bfloat16", "float16"),
    )
    parser.add_argument(
        "--baseline-repo-path",
        type=str,
        default="/apdcephfs_cq10/share_1603164/user/schmittzhu/code/DCASE2024_seld_baseline",
    )
    parser.add_argument("--seld233-task-id", type=str, default="233")
    parser.add_argument("--seld233-checkpoint-path", type=str, default=DEFAULT_SELD233_CKPT)
    parser.add_argument("--seld233-feature-stats-dir", type=str, default=DEFAULT_SELD233_STATS_DIR)
    parser.add_argument(
        "--seld233-feature-cache-manifest",
        type=str,
        default=None,
        help="Optional manifest.json produced by precompute_seld233_feature_cache.py. "
        "When set, the collator loads cached feature_bridge outputs and still runs the SELD233 backbone online.",
    )
    parser.add_argument(
        "--seld233-hidden-cache-manifest",
        type=str,
        default=None,
        help="Optional manifest.json produced by precompute_seld233_hidden_cache.py. "
        "When set, the collator loads cached SELD233 hidden states instead of running "
        "feature_bridge + backbone online.",
    )
    parser.add_argument("--output-dir", type=str, default=DEFAULT_OUTPUT_DIR)
    parser.add_argument(
        "--resume-checkpoint-path",
        type=str,
        default=None,
        help="Path to a saved *_trainable.pt checkpoint to resume from.",
    )
    parser.add_argument(
        "--resume-tag",
        type=str,
        default=None,
        help="Checkpoint tag under <output-dir>/checkpoints, e.g. 'last', 'best', or 'epoch_001'. Ignored when --resume-checkpoint-path is set.",
    )
    parser.add_argument(
        "--resume-model-only",
        action="store_true",
        help="Resume model weights only and reset optimizer/scheduler state.",
    )
    parser.add_argument("--save-full-model", action="store_true")
    parser.add_argument("--save-every-epoch", action="store_true")
    parser.add_argument("--save-every-n-optimizer-steps", type=int, default=1000)
    parser.add_argument("--gradient-checkpointing", action="store_true")
    parser.add_argument("--spatial-fp32", action="store_true")
    parser.add_argument("--optimizer-step-per-batch", action="store_true")
    parser.add_argument("--spatial-backbone-fp32", action="store_true")
    parser.add_argument("--valid-generate-batch-size", type=int, default=1)
    parser.add_argument("--valid-generate-max-samples", type=int, default=32)
    parser.add_argument("--valid-max-new-tokens", type=int, default=32)
    parser.add_argument("--valid-num-beams", type=int, default=1)
    parser.add_argument("--valid-do-sample", action="store_true")
    mode_group = parser.add_mutually_exclusive_group()
    mode_group.add_argument(
        "--freeze-spatial-only",
        dest="train_mode",
        action="store_const",
        const="spatial_only",
        help="Only train the spatial adapter and projector.",
    )
    mode_group.add_argument(
        "--train-spatial-lora",
        dest="train_mode",
        action="store_const",
        const="spatial_lora",
        help="Train spatial encoder + adapter + projector + LLM LoRA.",
    )
    mode_group.add_argument(
        "--train-adapter-lora",
        dest="train_mode",
        action="store_const",
        const="adapter_lora",
        help="Freeze the spatial encoder backbone and train adapter + projector + LLM LoRA.",
    )
    mode_group.add_argument(
        "--train-all",
        dest="train_mode",
        action="store_const",
        const="all",
        help="Train all model parameters.",
    )
    parser.add_argument("--lora-r", type=int, default=16)
    parser.add_argument("--lora-alpha", type=int, default=32)
    parser.add_argument("--lora-dropout", type=float, default=0.05)
    parser.add_argument(
        "--lora-target-modules",
        nargs="+",
        default=list(DEFAULT_LORA_TARGET_MODULES),
    )
    parser.add_argument(
        "--lora-target-prefixes",
        nargs="+",
        default=["thinker.model"],
        help="Only apply LoRA to modules under these prefixes.",
    )
    parser.set_defaults(train_mode="all", save_every_epoch=True)
    args = parser.parse_args()
    args.qa_roots = resolve_qa_roots(args.qa_roots, args.qa_root, args.qa_version)
    args.qa_root = args.qa_roots[0]
    args.freeze_spatial_only = args.train_mode == "spatial_only"
    return args


def add_spur_repo_to_path(spur_repo_path: str) -> None:
    if spur_repo_path not in sys.path:
        sys.path.insert(0, spur_repo_path)


def dtype_from_name(name: str) -> torch.dtype:
    return {
        "float32": torch.float32,
        "bfloat16": torch.bfloat16,
        "float16": torch.float16,
    }[name]


def enable_gradient_checkpointing(model) -> None:
    if not hasattr(model, "gradient_checkpointing_enable"):
        return
    signature = inspect.signature(model.gradient_checkpointing_enable)
    if "gradient_checkpointing_kwargs" in signature.parameters:
        model.gradient_checkpointing_enable(
            gradient_checkpointing_kwargs={"use_reentrant": False}
        )
    else:
        model.gradient_checkpointing_enable()


def is_distributed() -> bool:
    return dist.is_available() and dist.is_initialized()


def get_rank() -> int:
    return dist.get_rank() if is_distributed() else 0


def get_world_size() -> int:
    return dist.get_world_size() if is_distributed() else 1


def is_main_process() -> bool:
    return get_rank() == 0


def rank0_print(*args, **kwargs) -> None:
    if is_main_process():
        print(*args, **kwargs)


def unwrap_model(model):
    return model.module if isinstance(model, DDP) else model


def distributed_barrier() -> None:
    if is_distributed():
        dist.barrier()


def setup_distributed(args: argparse.Namespace) -> argparse.Namespace:
    world_size = int(os.environ.get("WORLD_SIZE", "1"))
    args.distributed = world_size > 1
    if not args.distributed:
        args.rank = 0
        args.world_size = 1
        return args

    local_rank = args.local_rank
    if local_rank < 0:
        local_rank = int(os.environ.get("LOCAL_RANK", "-1"))
    if local_rank < 0:
        raise RuntimeError("Distributed launch detected but LOCAL_RANK is missing.")
    args.local_rank = local_rank
    args.rank = int(os.environ["RANK"])
    args.world_size = world_size

    if not torch.cuda.is_available():
        raise RuntimeError("Distributed training currently requires CUDA.")

    torch.cuda.set_device(local_rank)
    args.device = f"cuda:{local_rank}"
    backend = "nccl"
    dist.init_process_group(backend=backend, init_method="env://")
    return args


def cleanup_distributed() -> None:
    if is_distributed():
        dist.destroy_process_group()


def reduce_scalar_sum(value: float, device: str) -> float:
    if not is_distributed():
        return float(value)
    tensor = torch.tensor([value], dtype=torch.float64, device=device)
    dist.all_reduce(tensor, op=dist.ReduceOp.SUM)
    return float(tensor.item())


def sample_subset_indices(dataset_size: int, subset_ratio: float, seed: int, epoch: int) -> List[int]:
    if dataset_size <= 0:
        return []
    ratio = float(max(0.0, min(1.0, subset_ratio)))
    subset_size = dataset_size if ratio >= 1.0 else max(1, int(round(dataset_size * ratio)))
    subset_size = min(subset_size, dataset_size)
    rng = np.random.default_rng(seed + epoch)
    indices = rng.choice(dataset_size, size=subset_size, replace=False)
    return sorted(int(index) for index in indices.tolist())


def resolve_qa_split_path(qa_root: str, split_name: str) -> str:
    candidates = [
        os.path.join(qa_root, f"{split_name}.jsonl"),
        os.path.join(qa_root, f"{split_name}.json"),
    ]
    for candidate in candidates:
        if os.path.exists(candidate):
            return os.path.abspath(candidate)
    raise FileNotFoundError(
        f"Missing QA split '{split_name}' under {qa_root}. Checked: {candidates}"
    )


def resolve_qa_root(qa_root: Optional[str], qa_version: str) -> str:
    if qa_root is not None and str(qa_root).strip():
        return os.path.abspath(str(qa_root))
    subdir = QA_VERSION_TO_SUBDIR[qa_version]
    return os.path.abspath(os.path.join(DEFAULT_QA_DATASET_ROOT, subdir))


def resolve_qa_roots(
    qa_roots: Optional[List[str]],
    qa_root: Optional[str],
    qa_version: str,
) -> List[str]:
    if qa_roots:
        roots = [os.path.abspath(str(root)) for root in qa_roots if str(root).strip()]
        if not roots:
            raise ValueError("--qa-roots was provided but no valid roots were found.")
        return roots
    return [resolve_qa_root(qa_root, qa_version)]


def load_qa_records(qa_path: str, max_samples: Optional[int] = None) -> List[Dict[str, Any]]:
    qa_path = os.path.abspath(qa_path)
    records: List[Dict[str, Any]] = []
    if qa_path.endswith(".jsonl"):
        with open(qa_path, "r", encoding="utf-8") as handle:
            for line_index, line in enumerate(handle):
                if max_samples is not None and len(records) >= max_samples:
                    break
                line = line.strip()
                if not line:
                    continue
                record = json.loads(line)
                if not isinstance(record, dict):
                    raise ValueError(f"Expected JSON object at line {line_index} in {qa_path}")
                records.append(record)
        return records

    if qa_path.endswith(".json"):
        with open(qa_path, "r", encoding="utf-8") as handle:
            payload = json.load(handle)
        if isinstance(payload, list):
            iterable = payload
        elif isinstance(payload, dict) and isinstance(payload.get("records"), list):
            iterable = payload["records"]
        elif isinstance(payload, dict) and isinstance(payload.get("data"), list):
            iterable = payload["data"]
        else:
            raise ValueError(
                f"Unsupported QA JSON structure in {qa_path}. Expected a list or a dict with 'records'/'data'."
            )
        for record_index, record in enumerate(iterable):
            if max_samples is not None and len(records) >= max_samples:
                break
            if not isinstance(record, dict):
                raise ValueError(f"Expected JSON object at index {record_index} in {qa_path}")
            records.append(record)
        return records

    raise ValueError(f"Unsupported QA file format: {qa_path}")


def build_left_padded_text_batch(
    input_ids: torch.Tensor,
    attention_mask: torch.Tensor,
    prefix_lengths: torch.LongTensor,
    pad_token_id: int,
) -> Tuple[torch.Tensor, torch.Tensor]:
    max_length = int(prefix_lengths.max().item())
    batch_size = int(input_ids.shape[0])
    generation_input_ids = torch.full(
        (batch_size, max_length),
        fill_value=pad_token_id,
        dtype=input_ids.dtype,
    )
    generation_attention_mask = torch.zeros(
        (batch_size, max_length),
        dtype=attention_mask.dtype,
    )
    for index, prefix_length in enumerate(prefix_lengths.tolist()):
        start = max_length - prefix_length
        generation_input_ids[index, start:] = input_ids[index, :prefix_length]
        generation_attention_mask[index, start:] = 1
    return generation_input_ids, generation_attention_mask


class QAAudioJsonlDataset(Dataset):
    def __init__(
        self,
        jsonl_path: str,
        max_samples: Optional[int] = None,
        feature_cache_manifest_path: Optional[str] = None,
        hidden_cache_manifest_path: Optional[str] = None,
    ) -> None:
        self.records: List[Dict[str, Any]] = []
        feature_cache_manifest = load_tensor_cache_manifest(feature_cache_manifest_path)
        hidden_cache_manifest = load_hidden_cache_manifest(hidden_cache_manifest_path)
        raw_records = load_qa_records(jsonl_path, max_samples=max_samples)
        for record_index, record in enumerate(raw_records):
            audio_path = record.get("audio_path")
            prompt = record.get("prompt")
            answer = record.get("answer")
            if not audio_path or not os.path.exists(audio_path):
                raise FileNotFoundError(
                    f"Missing audio_path for record {record_index} in {jsonl_path}: {audio_path}"
                )
            if prompt is None or answer is None:
                raise ValueError(
                    f"Each record must contain prompt and answer. Broken record {record_index} in {jsonl_path}"
                )
            resolved_audio_path = os.path.abspath(audio_path)
            if feature_cache_manifest is not None:
                cache_path = feature_cache_manifest.get(resolved_audio_path)
                if cache_path is None:
                    raise KeyError(
                        f"Audio path missing from feature cache manifest: {resolved_audio_path}"
                    )
                record["seld233_feature_cache_path"] = cache_path
            if hidden_cache_manifest is not None:
                cache_path = hidden_cache_manifest.get(resolved_audio_path)
                if cache_path is None:
                    raise KeyError(
                        f"Audio path missing from hidden cache manifest: {resolved_audio_path}"
                    )
                record["seld233_hidden_cache_path"] = cache_path
            self.records.append(record)

    def __len__(self) -> int:
        return len(self.records)

    def __getitem__(self, index: int) -> Dict[str, Any]:
        return self.records[index]


def build_qa_dataset(
    qa_roots: List[str],
    split_name: str,
    max_samples: Optional[int],
    feature_cache_manifest_path: Optional[str],
    hidden_cache_manifest_path: Optional[str],
) -> Tuple[Dataset, List[str], List[int]]:
    split_paths: List[str] = []
    datasets: List[Dataset] = []
    dataset_sizes: List[int] = []

    for qa_root in qa_roots:
        split_path = resolve_qa_split_path(qa_root, split_name)
        dataset = QAAudioJsonlDataset(
            split_path,
            max_samples=max_samples,
            feature_cache_manifest_path=feature_cache_manifest_path,
            hidden_cache_manifest_path=hidden_cache_manifest_path,
        )
        split_paths.append(split_path)
        datasets.append(dataset)
        dataset_sizes.append(len(dataset))

    if len(datasets) == 1:
        return datasets[0], split_paths, dataset_sizes
    return ConcatDataset(datasets), split_paths, dataset_sizes


@dataclass
class SpatialQACollator:
    processor: Any
    ignore_index: int = -100
    sample_rate: int = SAMPLE_RATE
    max_audio_samples: int = MAX_AUDIO_SAMPLES
    include_generation_inputs: bool = False
    feature_cache_store: Optional[OrderedDict[str, Dict[str, torch.Tensor]]] = None
    hidden_cache_store: Optional[OrderedDict[str, Dict[str, torch.Tensor]]] = None
    feature_cache_max_entries: int = 32
    hidden_cache_max_entries: int = 128

    def __call__(self, features: List[Dict[str, Any]]) -> Dict[str, Any]:
        audio_arrays: List[np.ndarray] = []
        full_texts: List[str] = []
        prefix_texts: List[str] = []
        answer_suffix_texts: List[str] = []
        meta: List[Dict[str, Any]] = []
        eos_token = getattr(self.processor.tokenizer, "eos_token", None)
        if not eos_token:
            raise ValueError("Tokenizer is missing eos_token; cannot append EOS to supervised answers.")

        for feature in features:
            wav, sr = sf.read(feature["audio_path"], dtype="float32", always_2d=True)
            if sr != self.sample_rate:
                raise ValueError(
                    f"Expected {self.sample_rate} Hz audio, got {sr} for {feature['audio_path']}"
                )
            wav = wav.T
            if wav.shape[0] != 4:
                raise ValueError(
                    f"Expected 4-channel FOA audio, got shape {wav.shape} for {feature['audio_path']}"
                )
            if wav.shape[1] > self.max_audio_samples:
                wav = wav[:, : self.max_audio_samples]

            prefix_text = (
                f"{self.processor.audio_token}{self.processor.spatial_token}\n"
                f"{feature['prompt'].rstrip()}\n"
            )
            answer_text = str(feature["answer"]).strip()
            answer_suffix_text = answer_text + eos_token
            full_text = prefix_text + answer_suffix_text

            audio_arrays.append(wav.astype(np.float32, copy=False))
            prefix_texts.append(prefix_text)
            answer_suffix_texts.append(answer_suffix_text)
            full_texts.append(full_text)
            meta.append(
                {
                    "pair_id": feature.get("pair_id"),
                    "task_name": feature.get("task_name"),
                    "answer": feature.get("answer"),
                    "audio_path": feature.get("audio_path"),
                    "prompt": feature.get("prompt"),
                    "question": feature.get("question"),
                }
            )

        feature_payload = self._build_feature_cache_payload(features)
        hidden_payload = self._build_hidden_cache_payload(features)
        if feature_payload and hidden_payload:
            raise ValueError("Feature cache and hidden cache cannot be enabled in the same batch.")

        processor_kwargs = dict(
            text=full_texts,
            audio=audio_arrays,
            padding=True,
            return_tensors="pt",
        )
        processor_kwargs.update(feature_payload)
        processor_kwargs.update(hidden_payload)
        batch = self.processor(**processor_kwargs)

        labels = batch["input_ids"].clone()
        if "attention_mask" in batch:
            labels = labels.masked_fill(batch["attention_mask"] == 0, self.ignore_index)

        prefix_lengths = self._compute_prefix_lengths(
            batch=batch,
            answer_suffix_texts=answer_suffix_texts,
        )
        for index, prefix_length in enumerate(prefix_lengths.tolist()):
            labels[index, :prefix_length] = self.ignore_index

        if (labels != self.ignore_index).sum(dim=1).min().item() <= 0:
            raise ValueError("At least one sample has no supervised answer tokens left.")

        batch["labels"] = labels
        batch["meta"] = meta
        batch["prefix_lengths"] = prefix_lengths
        if self.include_generation_inputs:
            generation_batch = self._build_generation_batch(
                batch=batch,
                prefix_lengths=prefix_lengths,
            )
            for key, value in generation_batch.items():
                if isinstance(value, torch.Tensor):
                    batch[f"gen_{key}"] = value
        return batch

    def _build_hidden_cache_payload(self, features: List[Dict[str, Any]]) -> Dict[str, torch.Tensor]:
        cache_paths = [feature.get("seld233_hidden_cache_path") for feature in features]
        if not any(cache_paths):
            return {}
        if not all(cache_paths):
            raise ValueError("Either every sample in the batch must provide seld233_hidden_cache_path, or none may.")

        cache_entries = [self._load_hidden_cache(cache_path) for cache_path in cache_paths]
        hidden_lengths = torch.tensor(
            [int(entry["seld233_hidden_lengths"]) for entry in cache_entries],
            dtype=torch.long,
        )
        max_hidden_steps = int(hidden_lengths.max().item())
        hidden_dim = int(cache_entries[0]["seld233_hidden_states"].shape[-1])
        hidden_states = torch.zeros(
            (len(cache_entries), max_hidden_steps, hidden_dim),
            dtype=cache_entries[0]["seld233_hidden_states"].dtype,
        )
        for index, entry in enumerate(cache_entries):
            current_hidden = entry["seld233_hidden_states"]
            current_length = int(hidden_lengths[index].item())
            if current_hidden.ndim != 2:
                raise ValueError(
                    "Cached seld233_hidden_states must have shape [T_seld, D_seld], "
                    f"got {tuple(current_hidden.shape)} for {cache_paths[index]}"
                )
            if current_hidden.shape[0] != current_length:
                raise ValueError(
                    f"Cached hidden length mismatch for {cache_paths[index]}: "
                    f"{current_hidden.shape[0]} vs {current_length}"
                )
            hidden_states[index, :current_length] = current_hidden

        hidden_attention_mask = (
            torch.arange(max_hidden_steps).unsqueeze(0) < hidden_lengths.unsqueeze(1)
        )
        return {
            "seld233_hidden_states": hidden_states,
            "seld233_hidden_attention_mask": hidden_attention_mask,
            "seld233_hidden_lengths": hidden_lengths,
        }

    def _build_feature_cache_payload(self, features: List[Dict[str, Any]]) -> Dict[str, torch.Tensor]:
        cache_paths = [feature.get("seld233_feature_cache_path") for feature in features]
        if not any(cache_paths):
            return {}
        if not all(cache_paths):
            raise ValueError("Either every sample in the batch must provide seld233_feature_cache_path, or none may.")

        cache_entries = [self._load_feature_cache(cache_path) for cache_path in cache_paths]
        feature_lengths = torch.tensor(
            [int(entry["seld233_feature_lengths"]) for entry in cache_entries],
            dtype=torch.long,
        )
        max_feature_steps = int(feature_lengths.max().item())
        num_channels = int(cache_entries[0]["seld233_features"].shape[0])
        num_mels = int(cache_entries[0]["seld233_features"].shape[-1])
        feature_tensor = torch.zeros(
            (len(cache_entries), num_channels, max_feature_steps, num_mels),
            dtype=cache_entries[0]["seld233_features"].dtype,
        )
        for index, entry in enumerate(cache_entries):
            current_features = entry["seld233_features"]
            current_length = int(feature_lengths[index].item())
            if current_features.ndim != 3:
                raise ValueError(
                    "Cached seld233_features must have shape [7, T_feat, M], "
                    f"got {tuple(current_features.shape)} for {cache_paths[index]}"
                )
            if current_features.shape[1] != current_length:
                raise ValueError(
                    f"Cached feature length mismatch for {cache_paths[index]}: "
                    f"{current_features.shape[1]} vs {current_length}"
                )
            feature_tensor[index, :, :current_length, :] = current_features

        feature_attention_mask = (
            torch.arange(max_feature_steps).unsqueeze(0) < feature_lengths.unsqueeze(1)
        )
        return {
            "seld233_features": feature_tensor,
            "seld233_feature_attention_mask": feature_attention_mask,
            "seld233_feature_lengths": feature_lengths,
        }

    def _load_feature_cache(self, cache_path: str) -> Dict[str, torch.Tensor]:
        if self.feature_cache_max_entries > 0:
            if self.feature_cache_store is None:
                self.feature_cache_store = OrderedDict()
            cached = self.feature_cache_store.get(cache_path)
            if cached is not None:
                self.feature_cache_store.move_to_end(cache_path)
                return cached

        payload = torch.load(cache_path, map_location="cpu")
        if "seld233_features" not in payload:
            raise KeyError(f"Feature cache missing 'seld233_features': {cache_path}")
        feature_tensor = torch.as_tensor(payload["seld233_features"])
        if feature_tensor.ndim != 3:
            raise ValueError(
                f"Cached seld233_features must have shape [7, T_feat, M], got {tuple(feature_tensor.shape)}"
            )
        if "seld233_feature_lengths" in payload:
            feature_length = int(torch.as_tensor(payload["seld233_feature_lengths"]).item())
        else:
            feature_length = int(feature_tensor.shape[1])
        cached = {
            "seld233_features": feature_tensor.to(dtype=feature_tensor.dtype).contiguous(),
            "seld233_feature_lengths": torch.tensor(feature_length, dtype=torch.long),
        }
        if self.feature_cache_max_entries > 0 and self.feature_cache_store is not None:
            self.feature_cache_store[cache_path] = cached
            self.feature_cache_store.move_to_end(cache_path)
            while len(self.feature_cache_store) > int(self.feature_cache_max_entries):
                self.feature_cache_store.popitem(last=False)
        return cached

    def _load_hidden_cache(self, cache_path: str) -> Dict[str, torch.Tensor]:
        if self.hidden_cache_max_entries > 0:
            if self.hidden_cache_store is None:
                self.hidden_cache_store = OrderedDict()
            cached = self.hidden_cache_store.get(cache_path)
            if cached is not None:
                self.hidden_cache_store.move_to_end(cache_path)
                return cached

        payload = torch.load(cache_path, map_location="cpu")
        if "seld233_hidden_states" not in payload:
            raise KeyError(f"Hidden cache missing 'seld233_hidden_states': {cache_path}")
        hidden_states = torch.as_tensor(payload["seld233_hidden_states"])
        if hidden_states.ndim != 2:
            raise ValueError(
                f"Cached seld233_hidden_states must have shape [T_seld, D_seld], got {tuple(hidden_states.shape)}"
            )
        if "seld233_hidden_lengths" in payload:
            hidden_length = int(torch.as_tensor(payload["seld233_hidden_lengths"]).item())
        else:
            hidden_length = int(hidden_states.shape[0])
        cached = {
            "seld233_hidden_states": hidden_states.to(dtype=hidden_states.dtype).contiguous(),
            "seld233_hidden_lengths": torch.tensor(hidden_length, dtype=torch.long),
        }
        if self.hidden_cache_max_entries > 0 and self.hidden_cache_store is not None:
            self.hidden_cache_store[cache_path] = cached
            self.hidden_cache_store.move_to_end(cache_path)
            while len(self.hidden_cache_store) > int(self.hidden_cache_max_entries):
                self.hidden_cache_store.popitem(last=False)
        return cached

    def _compute_prefix_lengths(
        self,
        batch: Dict[str, Any],
        answer_suffix_texts: List[str],
    ) -> torch.LongTensor:
        answer_batch = self.processor.tokenizer(
            answer_suffix_texts,
            padding=True,
            return_tensors="pt",
            add_special_tokens=False,
        )
        answer_lengths = answer_batch["attention_mask"].sum(dim=1).to(dtype=torch.long)
        valid_lengths = batch["attention_mask"].sum(dim=1).to(dtype=torch.long)
        prefix_lengths = valid_lengths - answer_lengths
        if (prefix_lengths < 0).any():
            raise ValueError(
                "Computed negative prefix length; answer tokenization exceeds full input length."
            )
        return prefix_lengths

    def _expand_modal_placeholders(
        self,
        prefix_text: str,
        audio_count: int,
        spatial_count: int,
        video_count: int,
    ) -> str:
        if self.processor.audio_token in prefix_text:
            prefix_text = prefix_text.replace(self.processor.audio_token, self.processor.audio_token * audio_count, 1)
        if self.processor.spatial_token in prefix_text:
            prefix_text = prefix_text.replace(
                self.processor.spatial_token,
                self.processor.spatial_token * spatial_count,
                1,
            )
        if self.processor.video_token in prefix_text:
            prefix_text = prefix_text.replace(self.processor.video_token, self.processor.video_token * video_count, 1)
        return prefix_text

    def _build_generation_batch(
        self,
        batch: Dict[str, Any],
        prefix_lengths: torch.LongTensor,
    ) -> Dict[str, torch.Tensor]:
        pad_token_id = int(self.processor.tokenizer.pad_token_id or 0)
        generation_input_ids, generation_attention_mask = build_left_padded_text_batch(
            input_ids=batch["input_ids"],
            attention_mask=batch["attention_mask"],
            prefix_lengths=prefix_lengths,
            pad_token_id=pad_token_id,
        )

        generation_batch: Dict[str, torch.Tensor] = {
            "input_ids": generation_input_ids,
            "attention_mask": generation_attention_mask,
        }
        for key, value in list(batch.items()):
            if key in {"input_ids", "attention_mask", "labels", "meta", "prefix_lengths"}:
                continue
            if isinstance(value, torch.Tensor):
                generation_batch[key] = value
        return generation_batch


def make_loader(
    dataset: Dataset,
    collator: SpatialQACollator,
    batch_size: int,
    num_workers: int,
    shuffle: bool,
    sampler=None,
    persistent_workers: bool = False,
    prefetch_factor: int = 2,
) -> DataLoader:
    loader_kwargs = {
        "dataset": dataset,
        "batch_size": batch_size,
        "shuffle": shuffle if sampler is None else False,
        "sampler": sampler,
        "num_workers": num_workers,
        "pin_memory": torch.cuda.is_available(),
        "collate_fn": collator,
    }
    if num_workers > 0:
        loader_kwargs["persistent_workers"] = bool(persistent_workers)
        loader_kwargs["prefetch_factor"] = int(prefetch_factor)
    return DataLoader(**loader_kwargs)


def load_hidden_cache_manifest(hidden_cache_manifest_path: Optional[str]) -> Optional[Dict[str, str]]:
    return load_tensor_cache_manifest(hidden_cache_manifest_path)


def load_tensor_cache_manifest(cache_manifest_path: Optional[str]) -> Optional[Dict[str, str]]:
    if cache_manifest_path is None:
        return None
    with open(cache_manifest_path, "r", encoding="utf-8") as handle:
        payload = json.load(handle)

    manifest_root = os.path.dirname(os.path.abspath(cache_manifest_path))
    if isinstance(payload, dict) and "entries" in payload:
        entries = payload["entries"]
        cache_root = payload.get("cache_dir", manifest_root)
    else:
        entries = payload
        cache_root = manifest_root

    if not isinstance(entries, dict):
        raise ValueError("Cache manifest must be a JSON object or contain an 'entries' object.")

    resolved: Dict[str, str] = {}
    for audio_path, cache_path in entries.items():
        absolute_audio_path = os.path.abspath(audio_path)
        if not os.path.isabs(cache_path):
            cache_path = os.path.join(cache_root, cache_path)
        resolved[absolute_audio_path] = os.path.abspath(cache_path)
    return resolved


def build_processor(model_id: str):
    from spatial_qwen.model.processing_qwen2_5_omni import Qwen2_5OmniProcessor
    from spatial_qwen.model.processing_spatial import Qwen2_5OmniSpatialProcessor

    base_processor = Qwen2_5OmniProcessor.from_pretrained(model_id)
    return Qwen2_5OmniSpatialProcessor(
        image_processor=base_processor.image_processor,
        feature_extractor=base_processor.feature_extractor,
        tokenizer=base_processor.tokenizer,
        chat_template=base_processor.chat_template,
    )


def infer_feature_to_seld_ratio(task_params: Dict[str, Any]) -> int:
    feature_sequence_length = task_params.get("feature_sequence_length")
    label_sequence_length = task_params.get("label_sequence_length")
    if feature_sequence_length is not None and label_sequence_length:
        ratio = int(round(float(feature_sequence_length) / float(label_sequence_length)))
        if ratio > 0:
            return ratio
    t_pool_size = task_params.get("t_pool_size")
    if isinstance(t_pool_size, (list, tuple)) and len(t_pool_size) > 0:
        ratio = int(t_pool_size[0])
        if ratio > 0:
            return ratio
    return 5


def load_seld_task_params(baseline_repo_path: str, task_id: str) -> Dict[str, Any]:
    baseline_repo_abs = os.path.abspath(baseline_repo_path)
    if baseline_repo_abs not in sys.path:
        sys.path.insert(0, baseline_repo_abs)
    import parameters

    return parameters.get_params(str(task_id))


def build_model(args: argparse.Namespace, processor):
    from spatial_qwen.model.configuration import Qwen2_5OmniConfig
    from spatial_qwen.model.modeling_spatial_thinker import Qwen2_5OmniSpatialForConditionalGeneration

    config = Qwen2_5OmniConfig.from_pretrained(args.model_id)
    config.loss_type = "ForCausalLMLoss"
    thinker_config = config.thinker_config
    task_params = load_seld_task_params(args.baseline_repo_path, args.seld233_task_id)
    thinker_config.loss_type = "ForCausalLMLoss"
    thinker_config.use_seld233_spatial_modality = True
    thinker_config.seld233_checkpoint_path = args.seld233_checkpoint_path
    thinker_config.seld233_baseline_repo_path = args.baseline_repo_path
    thinker_config.seld233_task_id = str(args.seld233_task_id)
    if args.seld233_feature_stats_dir == DEFAULT_SELD233_STATS_DIR and str(args.seld233_task_id) != "233":
        thinker_config.seld233_feature_stats_dir = task_params["feat_label_dir"]
    else:
        thinker_config.seld233_feature_stats_dir = args.seld233_feature_stats_dir
    thinker_config.seld233_hop_length = int(task_params.get("hop_len", 320))
    thinker_config.seld233_feature_to_seld_ratio = infer_feature_to_seld_ratio(task_params)
    thinker_config.seld233_num_mel_bins = int(task_params.get("nb_mel_bins", thinker_config.seld233_num_mel_bins))
    thinker_config.seld233_max_audio_seconds = float(MAX_AUDIO_SECONDS)
    thinker_config.seld233_freeze_backbone = args.train_mode in {"spatial_only", "adapter_lora"}

    model = Qwen2_5OmniSpatialForConditionalGeneration.from_pretrained(
        args.model_id,
        config=config,
        torch_dtype=dtype_from_name(args.dtype),
        low_cpu_mem_usage=True,
    )
    processor.sync_spatial_tokenizer_with_model(model)
    model.disable_talker()
    if args.gradient_checkpointing:
        enable_gradient_checkpointing(model)
        model.config.use_cache = False
        model.thinker.config.use_cache = False
    model.to(args.device)
    if args.train_mode == "spatial_lora":
        materialize_spatial_backbone(model, args.device)
    if args.spatial_fp32:
        cast_spatial_modules_to_fp32(model)
    if args.spatial_backbone_fp32 and args.train_mode == "spatial_lora":
        cast_spatial_backbone_to_fp32(model)
    return model


def cast_spatial_modules_to_fp32(model) -> None:
    for module_name in ("seld233_spatial_adapter", "seld233_spatial_projector"):
        module = getattr(model.thinker, module_name, None)
        if module is not None:
            module.to(dtype=torch.float32)


def materialize_spatial_backbone(model, device: str) -> None:
    backbone = getattr(model.thinker, "seld233_backbone", None)
    if backbone is None:
        raise RuntimeError("Model thinker is missing seld233_backbone.")
    backbone.freeze_backbone = False
    baseline_model = backbone._get_or_create_model(torch.device(device))
    for parameter in baseline_model.parameters():
        parameter.requires_grad_(True)
    baseline_model.train()


def cast_spatial_backbone_to_fp32(model) -> None:
    backbone = getattr(model.thinker, "seld233_backbone", None)
    if backbone is None or getattr(backbone, "_baseline_model", None) is None:
        return
    backbone._baseline_model.to(dtype=torch.float32)


def freeze_all_but_spatial_modules(model) -> List[str]:
    enabled: List[str] = []
    for _, parameter in model.named_parameters():
        parameter.requires_grad_(False)
    for name, parameter in model.named_parameters():
        if "seld233_spatial_adapter" in name or "seld233_spatial_projector" in name:
            parameter.requires_grad_(True)
            enabled.append(name)
    return enabled


def resolve_lora_target_modules(
    model,
    prefixes: List[str],
    target_suffixes: List[str],
) -> List[str]:
    resolved: List[str] = []
    for module_name, _module in model.named_modules():
        if not any(module_name.startswith(prefix) for prefix in prefixes):
            continue
        if module_name.rsplit(".", 1)[-1] in target_suffixes:
            resolved.append(module_name)
    if not resolved:
        raise ValueError(
            f"No LoRA target modules found under prefixes={prefixes} with suffixes={target_suffixes}."
        )
    return sorted(set(resolved))


def apply_llm_lora(model, args: argparse.Namespace):
    if get_peft_model is None or LoraConfig is None or TaskType is None:
        raise ImportError("peft is required for --train-spatial-lora.")

    target_modules = resolve_lora_target_modules(
        model,
        prefixes=list(args.lora_target_prefixes),
        target_suffixes=list(args.lora_target_modules),
    )
    lora_config = LoraConfig(
        r=int(args.lora_r),
        lora_alpha=int(args.lora_alpha),
        lora_dropout=float(args.lora_dropout),
        bias="none",
        task_type=TaskType.CAUSAL_LM,
        target_modules=target_modules,
    )
    model = get_peft_model(model, lora_config)
    if args.gradient_checkpointing:
        if hasattr(model, "enable_input_require_grads"):
            model.enable_input_require_grads()
        enable_gradient_checkpointing(model)
    return model, target_modules


def configure_spatial_lora_training(model, args: argparse.Namespace) -> List[str]:
    enabled: List[str] = []
    for _, parameter in model.named_parameters():
        parameter.requires_grad_(False)

    for name, parameter in model.named_parameters():
        if "seld233_backbone" in name and (".fnn_list." in name or ".sed_head." in name):
            continue
        if (
            "seld233_backbone" in name
            or "seld233_spatial_adapter" in name
            or "seld233_spatial_projector" in name
            or "lora_" in name
        ):
            parameter.requires_grad_(True)
            enabled.append(name)
    return enabled


def configure_adapter_lora_training(model, args: argparse.Namespace) -> List[str]:
    enabled: List[str] = []
    for _, parameter in model.named_parameters():
        parameter.requires_grad_(False)

    for name, parameter in model.named_parameters():
        if (
            "seld233_spatial_adapter" in name
            or "seld233_spatial_projector" in name
            or "lora_" in name
        ):
            parameter.requires_grad_(True)
            enabled.append(name)
    return enabled


def build_optimizer(model, lr: float, weight_decay: float) -> torch.optim.Optimizer:
    decay_params = []
    no_decay_params = []
    for name, parameter in model.named_parameters():
        if not parameter.requires_grad:
            continue
        if parameter.ndim == 1 or name.endswith(".bias") or "norm" in name.lower():
            no_decay_params.append(parameter)
        else:
            decay_params.append(parameter)
    param_groups = [
        {"params": decay_params, "weight_decay": weight_decay},
        {"params": no_decay_params, "weight_decay": 0.0},
    ]
    return torch.optim.AdamW(param_groups, lr=lr)


def resolve_resume_checkpoint_path(args: argparse.Namespace) -> Optional[str]:
    if args.resume_checkpoint_path is not None:
        return os.path.abspath(args.resume_checkpoint_path)
    if args.resume_tag:
        return os.path.abspath(
            os.path.join(args.output_dir, "checkpoints", f"{args.resume_tag}_trainable.pt")
        )
    return None


def infer_best_valid_from_output_dir(output_dir: str) -> Tuple[float, int]:
    best_path = os.path.join(output_dir, "checkpoints", "best_trainable.pt")
    if not os.path.exists(best_path):
        return float("inf"), -1
    payload = torch.load(best_path, map_location="cpu")
    metrics = payload.get("metrics") or {}
    valid_loss = float(metrics.get("valid_loss", float("inf")))
    epoch = int(payload.get("epoch", -1))
    return valid_loss, epoch


def resume_training_state(
    model,
    optimizer,
    scheduler,
    resume_checkpoint_path: str,
    resume_model_only: bool,
    device: str,
) -> Dict[str, Any]:
    checkpoint = torch.load(resume_checkpoint_path, map_location="cpu")
    trainable_state = checkpoint.get("trainable_state_dict", checkpoint)
    load_result = unwrap_model(model).load_state_dict(trainable_state, strict=False)

    if not resume_model_only:
        optimizer_state = checkpoint.get("optimizer")
        if optimizer_state is not None:
            optimizer.load_state_dict(optimizer_state)
        scheduler_state = checkpoint.get("scheduler")
        if scheduler is not None and scheduler_state is not None:
            scheduler.load_state_dict(scheduler_state)

    metrics = checkpoint.get("metrics") or {}
    if resume_model_only:
        resumed_epoch = 0
        global_optimizer_step = 0
    else:
        resumed_epoch = int(checkpoint.get("epoch", 0))
        scheduler_step = 0
        if scheduler is not None:
            scheduler_step = int(getattr(scheduler, "last_epoch", 0))
        global_optimizer_step = int(metrics.get("global_optimizer_step", 0))
        if global_optimizer_step <= 0:
            global_optimizer_step = max(
                scheduler_step,
                int(checkpoint.get("step", 0)),
            )
    return {
        "checkpoint": checkpoint,
        "load_result": load_result,
        "start_epoch": resumed_epoch + 1,
        "global_optimizer_step": global_optimizer_step,
        "global_micro_step": 0,
    }


def save_trainable_checkpoint(
    model,
    optimizer,
    scheduler,
    output_path: str,
    epoch: int,
    step: int,
    metrics: Dict[str, Any],
) -> None:
    model = unwrap_model(model)
    os.makedirs(os.path.dirname(output_path), exist_ok=True)
    trainable_state = {}
    for name, parameter in model.named_parameters():
        if parameter.requires_grad:
            trainable_state[name] = parameter.detach().cpu()
    payload = {
        "epoch": epoch,
        "step": step,
        "metrics": metrics,
        "trainable_state_dict": trainable_state,
        "optimizer": optimizer.state_dict(),
        "scheduler": scheduler.state_dict() if scheduler is not None else None,
    }
    torch.save(payload, output_path)


def save_artifacts(
    model,
    processor,
    optimizer,
    scheduler,
    args: argparse.Namespace,
    epoch: int,
    step: int,
    metrics: Dict[str, Any],
    tag: str,
) -> None:
    if not is_main_process():
        return
    ckpt_dir = os.path.join(args.output_dir, "checkpoints")
    os.makedirs(ckpt_dir, exist_ok=True)
    trainable_path = os.path.join(ckpt_dir, f"{tag}_trainable.pt")
    save_trainable_checkpoint(model, optimizer, scheduler, trainable_path, epoch, step, metrics)
    if args.save_full_model:
        full_dir = os.path.join(ckpt_dir, f"{tag}_full")
        unwrap_model(model).save_pretrained(full_dir)
        processor.save_pretrained(full_dir)


def to_device(batch: Dict[str, Any], device: str) -> Dict[str, torch.Tensor]:
    model_inputs: Dict[str, torch.Tensor] = {}
    for key, value in batch.items():
        if key in {"meta", "prefix_lengths"}:
            continue
        if isinstance(value, torch.Tensor):
            model_inputs[key] = value.to(device)
    return model_inputs


def count_supervised_tokens(labels: torch.Tensor, ignore_index: int = -100) -> int:
    return int((labels != ignore_index).sum().item())


def normalize_answer(text: str) -> str:
    return " ".join(str(text).strip().lower().split())


def compute_batch_loss(model, batch: Dict[str, Any], device: str) -> Tuple[torch.Tensor, Dict[str, Any]]:
    model_inputs = to_device(batch, device)
    outputs = model(**model_inputs, return_dict=True)
    if outputs.loss is None:
        raise RuntimeError("Model returned loss=None.")
    if not torch.isfinite(outputs.loss):
        raise RuntimeError(f"Non-finite loss encountered: {float(outputs.loss.detach().item())}")
    batch_stats = {
        "loss": float(outputs.loss.detach().item()),
        "logits_shape": tuple(outputs.logits.shape) if outputs.logits is not None else None,
        "supervised_tokens": count_supervised_tokens(batch["labels"]),
    }
    return outputs.loss, batch_stats


def evaluate(model, loader: DataLoader, device: str) -> Dict[str, float]:
    model.eval()
    total_weighted_loss = 0.0
    total_batches = 0
    total_supervised = 0
    progress = tqdm(
        loader,
        desc="valid",
        leave=False,
        disable=not is_main_process(),
    )
    with torch.no_grad():
        for batch in progress:
            loss, stats = compute_batch_loss(model, batch, device)
            total_weighted_loss += float(loss.detach().item()) * int(stats["supervised_tokens"])
            total_batches += 1
            total_supervised += int(stats["supervised_tokens"])
            if is_main_process():
                progress.set_postfix(
                    loss=f"{stats['loss']:.4f}",
                    supervised=int(stats["supervised_tokens"]),
                )
    if total_batches == 0:
        raise RuntimeError("Validation loader is empty.")
    total_weighted_loss = reduce_scalar_sum(total_weighted_loss, device)
    total_batches = int(reduce_scalar_sum(float(total_batches), device))
    total_supervised = int(reduce_scalar_sum(float(total_supervised), device))
    valid_loss = total_weighted_loss / max(total_supervised, 1)
    return {
        "valid_loss": valid_loss,
        "valid_batches": float(total_batches),
        "valid_supervised_tokens": float(total_supervised),
    }


def train_one_epoch(
    model,
    loader: DataLoader,
    optimizer: torch.optim.Optimizer,
    scheduler,
    device: str,
    grad_accum_steps: int,
    max_grad_norm: float,
    log_every: int,
    epoch: int,
    optimizer_step_per_batch: bool,
    writer=None,
    global_step_start: int = 0,
    global_optimizer_step_start: int = 0,
    on_optimizer_step=None,
) -> Dict[str, float]:
    model.train()
    optimizer.zero_grad(set_to_none=True)
    total_weighted_loss = 0.0
    total_batches = 0
    total_supervised = 0
    optimizer_steps = 0
    epoch_start = time.time()
    progress = tqdm(
        loader,
        desc=f"epoch {epoch}",
        leave=False,
        disable=not is_main_process(),
    )

    for step, batch in enumerate(progress, start=1):
        loss, stats = compute_batch_loss(model, batch, device)
        total_weighted_loss += stats["loss"] * int(stats["supervised_tokens"])
        total_batches += 1
        total_supervised += int(stats["supervised_tokens"])

        should_step = optimizer_step_per_batch or (step % grad_accum_steps == 0) or (step == len(loader))
        sync_context = nullcontext()
        if is_distributed() and isinstance(model, DDP) and not should_step:
            sync_context = model.no_sync()
        scaled_loss = loss / grad_accum_steps
        with sync_context:
            scaled_loss.backward()
        if should_step:
            if max_grad_norm > 0.0:
                torch.nn.utils.clip_grad_norm_(
                    [parameter for parameter in model.parameters() if parameter.requires_grad],
                    max_grad_norm,
                )
            optimizer.step()
            if scheduler is not None:
                scheduler.step()
            optimizer.zero_grad(set_to_none=True)
            optimizer_steps += 1
            if on_optimizer_step is not None:
                on_optimizer_step(
                    global_optimizer_step_start + optimizer_steps,
                    {
                        "epoch": epoch,
                        "micro_step": step,
                        "loss": float(stats["loss"]),
                        "supervised_tokens": int(stats["supervised_tokens"]),
                    },
                )

        current_lr = optimizer.param_groups[0]["lr"]
        if is_main_process():
            progress.set_postfix(
                step=f"{step}/{len(loader)}",
                loss=f"{stats['loss']:.4f}",
                lr=f"{current_lr:.2e}",
            )
        if writer is not None:
            global_micro_step = global_step_start + step
            writer.add_scalar("train/batch_loss", float(stats["loss"]), global_micro_step)
            writer.add_scalar("train/batch_supervised_tokens", float(stats["supervised_tokens"]), global_micro_step)
            writer.add_scalar("train/lr", float(current_lr), global_micro_step)

    elapsed = time.time() - epoch_start
    if total_batches == 0:
        raise RuntimeError("Training loader is empty.")
    total_weighted_loss = reduce_scalar_sum(total_weighted_loss, device)
    total_batches = int(reduce_scalar_sum(float(total_batches), device))
    total_supervised = int(reduce_scalar_sum(float(total_supervised), device))
    optimizer_steps = int(reduce_scalar_sum(float(optimizer_steps), device)) // max(get_world_size(), 1)
    train_loss = total_weighted_loss / max(total_supervised, 1)
    return {
        "train_loss": train_loss,
        "train_batches": float(total_batches),
        "train_supervised_tokens": float(total_supervised),
        "optimizer_steps": float(optimizer_steps),
        "epoch_seconds": elapsed,
        "micro_steps": float(total_batches),
    }


def dump_args(args: argparse.Namespace) -> None:
    if not is_main_process():
        return
    os.makedirs(args.output_dir, exist_ok=True)
    args_path = os.path.join(args.output_dir, "train_args.json")
    with open(args_path, "w", encoding="utf-8") as handle:
        json.dump(vars(args), handle, indent=2, sort_keys=True)


def save_processor_assets(processor, output_dir: str) -> None:
    if not is_main_process():
        return
    processor_dir = os.path.join(output_dir, "processor")
    os.makedirs(processor_dir, exist_ok=True)
    processor.save_pretrained(processor_dir)


def build_tensorboard_writer(output_dir: str):
    if not is_main_process():
        return None
    tb_dir = os.path.join(output_dir, "tensorboard")
    os.makedirs(tb_dir, exist_ok=True)
    return SummaryWriter(log_dir=tb_dir)


def format_prediction_preview(records: List[Dict[str, Any]]) -> str:
    if not records:
        return "No validation generation samples."
    lines: List[str] = []
    for index, record in enumerate(records[:10], start=1):
        lines.append(f"[{index}] pair_id={record.get('pair_id')} task={record.get('task_name')}")
        lines.append(f"Q: {record.get('prompt', '')}")
        lines.append(f"GT: {record.get('answer', '')}")
        lines.append(f"Pred: {record.get('prediction', '')}")
        lines.append(f"EM: {record.get('exact_match', 0)}")
        lines.append("")
    return "\n".join(lines).strip()


def build_generation_inputs(batch: Dict[str, Any], device: str) -> Dict[str, torch.Tensor]:
    generation_inputs: Dict[str, torch.Tensor] = {}
    for key, value in batch.items():
        if not key.startswith("gen_") or not isinstance(value, torch.Tensor):
            continue
        generation_inputs[key[4:]] = value.to(device)
    return generation_inputs


def run_validation_generation(
    model,
    processor,
    loader: DataLoader,
    device: str,
    epoch: int,
    output_dir: str,
    max_new_tokens: int,
    num_beams: int,
    do_sample: bool,
) -> Dict[str, float]:
    if not is_main_process():
        distributed_barrier()
        return {
            "valid_generate_examples": 0.0,
            "valid_exact_match": 0.0,
            "preview_records": [],
        }

    model.eval()
    predictions_dir = os.path.join(output_dir, "valid_predictions")
    os.makedirs(predictions_dir, exist_ok=True)
    prediction_path = os.path.join(predictions_dir, f"epoch_{epoch:03d}.jsonl")

    total_examples = 0
    exact_matches = 0
    preview_records: List[Dict[str, Any]] = []

    with open(prediction_path, "w", encoding="utf-8") as handle:
        with torch.no_grad():
            progress = tqdm(
                loader,
                desc=f"valid_gen e{epoch}",
                leave=False,
                disable=not is_main_process(),
            )
            for batch in progress:
                generation_inputs = build_generation_inputs(batch, device)
                generated = unwrap_model(model).generate(
                    **generation_inputs,
                    return_audio=False,
                    max_new_tokens=max_new_tokens,
                    num_beams=num_beams,
                    do_sample=do_sample,
                )
                prompt_lengths = generation_inputs["attention_mask"].sum(dim=1).tolist()
                generated = generated.detach().cpu()

                for index, prompt_length in enumerate(prompt_lengths):
                    prediction_ids = generated[index, int(prompt_length):]
                    prediction_text = processor.tokenizer.decode(
                        prediction_ids,
                        skip_special_tokens=True,
                    ).strip()
                    meta = batch["meta"][index]
                    answer_text = str(meta["answer"]).strip()
                    exact_match = int(normalize_answer(prediction_text) == normalize_answer(answer_text))
                    exact_matches += exact_match
                    total_examples += 1

                    record = {
                        "epoch": epoch,
                        "pair_id": meta.get("pair_id"),
                        "task_name": meta.get("task_name"),
                        "question": meta.get("question"),
                        "prompt": meta.get("prompt"),
                        "answer": answer_text,
                        "prediction": prediction_text,
                        "exact_match": exact_match,
                    }
                    if len(preview_records) < 10:
                        preview_records.append(record)
                    handle.write(json.dumps(record, ensure_ascii=False) + "\n")
                if total_examples > 0:
                    progress.set_postfix(
                        examples=total_examples,
                        em=f"{exact_matches / total_examples:.4f}",
                    )
    distributed_barrier()
    return {
        "valid_generate_examples": float(total_examples),
        "valid_exact_match": float(exact_matches / max(total_examples, 1)),
        "preview_records": preview_records,
    }


def print_dataset_preview(processor, batch: Dict[str, Any], split_name: str) -> None:
    audio_token_id = int(processor.tokenizer.convert_tokens_to_ids(processor.audio_token))
    spatial_token_id = int(processor.tokenizer.convert_tokens_to_ids(processor.spatial_token))
    print(f"== {split_name} Batch Preview ==")
    for key in (
        "input_ids",
        "attention_mask",
        "input_features",
        "feature_attention_mask",
        "spatial_audio",
        "spatial_audio_attention_mask",
        "spatial_audio_lengths",
        "seld233_features",
        "seld233_feature_attention_mask",
        "seld233_feature_lengths",
        "seld233_hidden_states",
        "seld233_hidden_attention_mask",
        "seld233_hidden_lengths",
        "spatial_token_lengths",
        "labels",
    ):
        if key not in batch:
            continue
        value = batch[key]
        if isinstance(value, torch.Tensor):
            print(f"{key}: shape={tuple(value.shape)} dtype={value.dtype}")
    print("prefix_lengths:", batch["prefix_lengths"].tolist())
    for index, meta in enumerate(batch["meta"]):
        audio_count = int((batch["input_ids"][index] == audio_token_id).sum().item())
        spatial_count = int((batch["input_ids"][index] == spatial_token_id).sum().item())
        supervised_count = count_supervised_tokens(batch["labels"][index])
        print(
            f"[{split_name} sample {index}] pair_id={meta['pair_id']} task={meta['task_name']} "
            f"audio_tokens={audio_count} spatial_tokens={spatial_count} supervised_answer_tokens={supervised_count}"
        )


def save_epoch_metrics(output_dir: str, epoch: int, metrics: Dict[str, Any]) -> None:
    if not is_main_process():
        return
    metrics_dir = os.path.join(output_dir, "metrics")
    os.makedirs(metrics_dir, exist_ok=True)
    metrics_path = os.path.join(metrics_dir, f"epoch_{epoch:03d}.json")
    with open(metrics_path, "w", encoding="utf-8") as handle:
        json.dump(metrics, handle, indent=2, sort_keys=True)


def build_epoch_valid_loaders(
    valid_dataset: Dataset,
    processor,
    args: argparse.Namespace,
    epoch: int,
) -> Tuple[DataLoader, DataLoader, int, int]:
    collator = SpatialQACollator(
        processor=processor,
        include_generation_inputs=False,
        feature_cache_max_entries=args.feature_cache_max_entries,
        hidden_cache_max_entries=args.hidden_cache_max_entries,
    )
    valid_generation_collator = SpatialQACollator(
        processor=processor,
        include_generation_inputs=True,
        feature_cache_max_entries=args.feature_cache_max_entries,
        hidden_cache_max_entries=args.hidden_cache_max_entries,
    )

    valid_indices = sample_subset_indices(
        dataset_size=len(valid_dataset),
        subset_ratio=args.valid_subset_ratio,
        seed=args.seed + 10000,
        epoch=epoch,
    )
    epoch_valid_dataset = Subset(valid_dataset, valid_indices)

    valid_sampler = DistributedSampler(epoch_valid_dataset, shuffle=False) if args.distributed else None
    valid_loader = make_loader(
        epoch_valid_dataset,
        collator,
        args.batch_size,
        args.num_workers,
        shuffle=False,
        sampler=valid_sampler,
        persistent_workers=args.persistent_workers,
        prefetch_factor=args.prefetch_factor,
    )

    generation_indices = valid_indices
    if args.valid_generate_max_samples is not None and len(generation_indices) > args.valid_generate_max_samples:
        generation_indices = generation_indices[: args.valid_generate_max_samples]
    epoch_generation_dataset = Subset(valid_dataset, generation_indices)
    valid_generation_loader = make_loader(
        epoch_generation_dataset,
        valid_generation_collator,
        args.valid_generate_batch_size,
        args.num_workers,
        shuffle=False,
        persistent_workers=args.persistent_workers,
        prefetch_factor=args.prefetch_factor,
    )
    return valid_loader, valid_generation_loader, len(valid_indices), len(generation_indices)


def main() -> None:
    args = parse_args()
    args = setup_distributed(args)
    np.random.seed(args.seed)
    torch.manual_seed(args.seed + get_rank())

    if args.device.startswith("cuda") and not torch.cuda.is_available():
        raise RuntimeError(f"Requested device {args.device}, but CUDA is not available.")
    if args.device == "cpu" and args.dtype != "float32":
        raise ValueError("CPU training should use --dtype float32.")

    add_spur_repo_to_path(args.spur_repo_path)
    dump_args(args)
    writer = build_tensorboard_writer(args.output_dir)
    if writer is not None:
        writer.add_text("config/args", json.dumps(vars(args), indent=2, sort_keys=True), 0)

    task_params = load_seld_task_params(args.baseline_repo_path, args.seld233_task_id)
    processor = build_processor(args.model_id)
    processor.seld233_num_feature_channels = int(task_params.get("num_feature_channels", 7))
    processor.seld233_num_mel_bins = int(task_params.get("nb_mel_bins", 64))
    processor.seld233_hop_length = int(task_params.get("hop_len", 320))
    processor.seld233_feature_to_seld_ratio = infer_feature_to_seld_ratio(task_params)
    processor.seld233_downsample_factor = 4
    save_processor_assets(processor, args.output_dir)
    if args.seld233_feature_cache_manifest is not None and args.seld233_hidden_cache_manifest is not None:
        raise ValueError("Use either --seld233-feature-cache-manifest or --seld233-hidden-cache-manifest, not both.")
    if args.seld233_hidden_cache_manifest is not None and args.train_mode not in {"spatial_only", "adapter_lora"}:
        raise ValueError(
            "Cached seld233 hidden states bypass feature_bridge + backbone, so they can only be used with "
            "--freeze-spatial-only or --train-adapter-lora. Disable --seld233-hidden-cache-manifest if you want to train the spatial encoder."
        )
    collator = SpatialQACollator(
        processor=processor,
        include_generation_inputs=False,
        feature_cache_max_entries=args.feature_cache_max_entries,
        hidden_cache_max_entries=args.hidden_cache_max_entries,
    )
    train_dataset, train_paths, train_sizes = build_qa_dataset(
        args.qa_roots,
        args.train_split,
        args.max_train_samples,
        args.seld233_feature_cache_manifest,
        args.seld233_hidden_cache_manifest,
    )
    valid_dataset, valid_paths, valid_sizes = build_qa_dataset(
        args.qa_roots,
        args.valid_split,
        args.max_valid_samples,
        args.seld233_feature_cache_manifest,
        args.seld233_hidden_cache_manifest,
    )
    train_sampler = DistributedSampler(train_dataset, shuffle=True) if args.distributed else None
    train_loader = make_loader(
        train_dataset,
        collator,
        args.batch_size,
        args.num_workers,
        shuffle=True,
        sampler=train_sampler,
        persistent_workers=args.persistent_workers,
        prefetch_factor=args.prefetch_factor,
    )
    preview_valid_loader, _, preview_valid_size, preview_generate_size = build_epoch_valid_loaders(
        valid_dataset=valid_dataset,
        processor=processor,
        args=args,
        epoch=1,
    )

    qa_root_summary = ", ".join(args.qa_roots)
    train_split_summary = ", ".join(
        f"{os.path.dirname(path)}:{args.train_split}={size}" for path, size in zip(train_paths, train_sizes)
    )
    valid_split_summary = ", ".join(
        f"{os.path.dirname(path)}:{args.valid_split}={size}" for path, size in zip(valid_paths, valid_sizes)
    )
    rank0_print(
        f"Loaded QA roots [{qa_root_summary}]: train={len(train_dataset)} valid={len(valid_dataset)} "
        f"train_components=[{train_split_summary}] valid_components=[{valid_split_summary}] "
        f"valid_subset_ratio={args.valid_subset_ratio:.3f} "
        f"preview_valid_subset={preview_valid_size} preview_valid_generate={preview_generate_size} "
        f"world_size={get_world_size()} "
        f"batch_size={args.batch_size} grad_accum_steps={args.grad_accum_steps}"
    )
    if is_main_process():
        print_dataset_preview(processor, next(iter(train_loader)), "train")
        print_dataset_preview(processor, next(iter(preview_valid_loader)), "valid")

    model = build_model(args, processor)
    lora_targets: List[str] = []
    if args.train_mode == "spatial_only":
        trainable_names = freeze_all_but_spatial_modules(model)
        rank0_print(f"Training spatial modules only. Trainable parameter tensors: {len(trainable_names)}")
    elif args.train_mode == "adapter_lora":
        model, lora_targets = apply_llm_lora(model, args)
        trainable_names = configure_adapter_lora_training(model, args)
        rank0_print(
            "Training spatial adapter + projector + LLM LoRA with frozen spatial encoder. "
            f"LoRA targets: {len(lora_targets)} modules. Trainable parameter tensors: {len(trainable_names)}"
        )
    elif args.train_mode == "spatial_lora":
        model, lora_targets = apply_llm_lora(model, args)
        trainable_names = configure_spatial_lora_training(model, args)
        rank0_print(
            "Training spatial encoder + adapter + projector + LLM LoRA. "
            f"LoRA targets: {len(lora_targets)} modules. Trainable parameter tensors: {len(trainable_names)}"
        )
    else:
        trainable_names = [name for name, parameter in model.named_parameters() if parameter.requires_grad]
        rank0_print(f"Training all model parameters. Trainable parameter tensors: {len(trainable_names)}")
    if not trainable_names:
        raise RuntimeError("No trainable parameters were enabled.")
    if lora_targets:
        rank0_print(f"Resolved LoRA target modules: {', '.join(lora_targets[:20])}")
    if writer is not None:
        writer.add_text("model/trainable_parameters", "\n".join(trainable_names[:500]), 0)
        if lora_targets:
            writer.add_text("model/lora_targets", "\n".join(lora_targets), 0)
    if args.distributed:
        model = DDP(
            model,
            device_ids=[args.local_rank],
            output_device=args.local_rank,
            find_unused_parameters=False,
            broadcast_buffers=False,
        )
        if args.train_mode in {"spatial_lora", "adapter_lora"} and args.gradient_checkpointing and hasattr(model, "_set_static_graph"):
            model._set_static_graph()

    optimizer = build_optimizer(model, lr=args.lr, weight_decay=args.weight_decay)
    total_optimizer_steps = (
        math.ceil(len(train_loader) / (1 if args.optimizer_step_per_batch else args.grad_accum_steps)) * args.epochs
    )
    warmup_steps = int(total_optimizer_steps * args.warmup_ratio)
    scheduler = None
    if total_optimizer_steps > 0:
        from transformers.optimization import get_cosine_schedule_with_warmup

        scheduler = get_cosine_schedule_with_warmup(
            optimizer,
            num_warmup_steps=warmup_steps,
            num_training_steps=total_optimizer_steps,
        )

    best_valid_loss, best_epoch = infer_best_valid_from_output_dir(args.output_dir)
    if not math.isfinite(best_valid_loss):
        best_valid_loss = float("inf")
        best_epoch = -1
    global_micro_step = 0
    global_optimizer_step = 0
    start_epoch = 1

    resume_checkpoint_path = resolve_resume_checkpoint_path(args)
    if resume_checkpoint_path is not None:
        if not os.path.exists(resume_checkpoint_path):
            raise FileNotFoundError(f"Resume checkpoint not found: {resume_checkpoint_path}")
        resume_state = resume_training_state(
            model=model,
            optimizer=optimizer,
            scheduler=scheduler,
            resume_checkpoint_path=resume_checkpoint_path,
            resume_model_only=args.resume_model_only,
            device=args.device,
        )
        start_epoch = int(resume_state["start_epoch"])
        global_optimizer_step = int(resume_state["global_optimizer_step"])
        global_micro_step = int(resume_state["global_micro_step"])
        load_result = resume_state["load_result"]
        rank0_print(
            f"Resumed from {resume_checkpoint_path}: next_epoch={start_epoch} "
            f"global_optimizer_step={global_optimizer_step} "
            f"missing_keys={len(load_result.missing_keys)} unexpected_keys={len(load_result.unexpected_keys)}"
        )
        if start_epoch > args.epochs:
            raise ValueError(
                f"Resume checkpoint is already at epoch {start_epoch - 1}, but --epochs={args.epochs}. "
                "Set --epochs to the total target epoch count after resuming."
            )

    def maybe_save_intermediate_checkpoint(current_global_optimizer_step: int, step_stats: Dict[str, Any]) -> None:
        if args.save_every_n_optimizer_steps <= 0:
            return
        if current_global_optimizer_step % int(args.save_every_n_optimizer_steps) != 0:
            return
        save_artifacts(
            model=model,
            processor=processor,
            optimizer=optimizer,
            scheduler=scheduler,
            args=args,
            epoch=int(step_stats["epoch"]),
            step=int(current_global_optimizer_step),
            metrics={
                "save_type": "optimizer_step",
                "epoch": int(step_stats["epoch"]),
                "micro_step": int(step_stats["micro_step"]),
                "loss": float(step_stats["loss"]),
                "supervised_tokens": int(step_stats["supervised_tokens"]),
                "global_optimizer_step": int(current_global_optimizer_step),
            },
            tag=f"step_{int(current_global_optimizer_step):07d}",
        )

    for epoch in range(start_epoch, args.epochs + 1):
        if train_sampler is not None:
            train_sampler.set_epoch(epoch)
        valid_loader, valid_generation_loader, epoch_valid_size, epoch_generate_size = build_epoch_valid_loaders(
            valid_dataset=valid_dataset,
            processor=processor,
            args=args,
            epoch=epoch,
        )
        train_stats = train_one_epoch(
            model=model,
            loader=train_loader,
            optimizer=optimizer,
            scheduler=scheduler,
            device=args.device,
            grad_accum_steps=max(1, args.grad_accum_steps),
            max_grad_norm=args.max_grad_norm,
            log_every=args.log_every,
            epoch=epoch,
            optimizer_step_per_batch=args.optimizer_step_per_batch,
            writer=writer,
            global_step_start=global_micro_step,
            global_optimizer_step_start=global_optimizer_step,
            on_optimizer_step=maybe_save_intermediate_checkpoint,
        )
        global_micro_step += int(train_stats["micro_steps"])
        global_optimizer_step += int(train_stats["optimizer_steps"])
        valid_stats = evaluate(model, valid_loader, args.device)
        distributed_barrier()
        generation_stats = run_validation_generation(
            model=model,
            processor=processor,
            loader=valid_generation_loader,
            device=args.device,
            epoch=epoch,
            output_dir=args.output_dir,
            max_new_tokens=args.valid_max_new_tokens,
            num_beams=args.valid_num_beams,
            do_sample=args.valid_do_sample,
        )
        preview_records = generation_stats.pop("preview_records", [])
        summary = {
            **train_stats,
            **valid_stats,
            **generation_stats,
            "valid_subset_size": float(epoch_valid_size),
            "valid_generation_size": float(epoch_generate_size),
        }
        if writer is not None:
            writer.add_scalar("epoch/train_loss", float(summary["train_loss"]), epoch)
            writer.add_scalar("epoch/valid_loss", float(summary["valid_loss"]), epoch)
            writer.add_scalar("epoch/valid_exact_match", float(summary["valid_exact_match"]), epoch)
            writer.add_scalar("epoch/optimizer_steps", float(summary["optimizer_steps"]), epoch)
            writer.add_scalar("epoch/epoch_seconds", float(summary["epoch_seconds"]), epoch)
            writer.add_scalar("epoch/train_supervised_tokens", float(summary["train_supervised_tokens"]), epoch)
            writer.add_scalar("epoch/valid_supervised_tokens", float(summary["valid_supervised_tokens"]), epoch)
            writer.add_scalar("epoch/valid_subset_size", float(summary["valid_subset_size"]), epoch)
            writer.add_scalar("epoch/valid_generation_size", float(summary["valid_generation_size"]), epoch)
            writer.add_text(
                f"valid_predictions/epoch_{epoch:03d}",
                format_prediction_preview(preview_records),
                epoch,
            )
            writer.flush()
        rank0_print(
            f"[epoch {epoch}] train_loss={summary['train_loss']:.6f} "
            f"valid_loss={summary['valid_loss']:.6f} "
            f"valid_exact_match={summary['valid_exact_match']:.4f} "
            f"valid_subset={int(summary['valid_subset_size'])} "
            f"optimizer_steps={int(summary['optimizer_steps'])} "
            f"epoch_seconds={summary['epoch_seconds']:.2f}"
        )
        save_epoch_metrics(args.output_dir, epoch, summary)

        if args.save_every_epoch:
            save_artifacts(
                model=model,
                processor=processor,
                optimizer=optimizer,
                scheduler=scheduler,
                args=args,
                epoch=epoch,
                step=int(summary["optimizer_steps"]),
                metrics=summary,
                tag=f"epoch_{epoch:03d}",
            )

        save_artifacts(
            model=model,
            processor=processor,
            optimizer=optimizer,
            scheduler=scheduler,
            args=args,
            epoch=epoch,
            step=int(summary["optimizer_steps"]),
            metrics=summary,
            tag="last",
        )

        if summary["valid_loss"] < best_valid_loss:
            best_valid_loss = summary["valid_loss"]
            best_epoch = epoch
            save_artifacts(
                model=model,
                processor=processor,
                optimizer=optimizer,
                scheduler=scheduler,
                args=args,
                epoch=epoch,
                step=int(summary["optimizer_steps"]),
                metrics=summary,
                tag="best",
            )
            rank0_print(f"Updated best checkpoint at epoch {epoch} with valid_loss={best_valid_loss:.6f}")

    rank0_print(
        f"Training complete. best_epoch={best_epoch} best_valid_loss={best_valid_loss:.6f} "
        f"output_dir={args.output_dir}"
    )
    if writer is not None:
        writer.close()
    cleanup_distributed()


if __name__ == "__main__":
    main()