thinker/config.py

"""HGA-Thinker configuration."""
import os, yaml
from dataclasses import dataclass, field, asdict
from typing import List, Dict, Optional, Any
import dataclasses as _dc


@dataclass
class TrainingConfig:
    learning_rate: float = 5e-5
    hga_lr_scale: float = 1.0
    emca_lr_scale: float = 1.0
    weight_decay: float = 0.01
    warmup_ratio: float = 0.03
    num_epochs: int = 3
    max_steps: int = -1
    batch_size: int = 6
    grad_accumulation_steps: int = 2
    gradient_clip_norm: float = 1.0
    max_audio_length: float = 30.0
    # ---- v2: per-batch audio cap ----
    # Maximum total number of audios allowed in a single batch (i.e. the
    # first dim of the stacked mel tensor going through the Whisper encoder).
    # Multi-audio samples (e.g. constrain_inf_pair_audio with up to 4 audios)
    # can otherwise blow up the encoder forward batch to bs * 4 = 16 and OOM
    # the GPU. The dynamic batch sampler greedily packs samples so that the
    # SUM of their audio counts stays <= this cap, while never exceeding
    # batch_size samples. Set to 0 or a value >= batch_size*max_audios to
    # disable (degrades to plain batching).
    max_audios_per_batch: int = 6
    eval_loss_steps: int = 500
    eval_generate_steps: int = 2000
    eval_samples_per_task: int = 100
    # How many random ref/hyp pairs to print per task at each generate eval.
    # 5 keeps the log compact; bump to 10 if you want richer qualitative view.
    eval_display_samples: int = 5
    save_steps: int = 2000
    logging_steps: int = 50
    output_dir: str = "outputs/align_hga"
    # Loss
    lambda_radius: float = 0.02
    radius_margin: float = 0.05


@dataclass
class ThinkerConfig:
    # Whisper
    whisper_path: str = ""
    encoder_dim: int = 1280
    num_whisper_layers: int = 32
    extract_layers: List[int] = field(
        default_factory=lambda: [3, 7, 11, 15, 19, 23, 27, 31]  # 0-indexed
    )
    target_frame_rate_hz: float = 12.5

    # HGA (per-layer Q/K/V weight modulation)
    # b_init_std=1e-4 ensures b ≠ 0 at step 0 so ∂L/∂c is non-zero from start.
    # All layers share the same c bounds — layer-aware bucketing removed since
    # Möbius bias makes c a real learnable parameter that finds its own
    # per-layer optimum without artificial floors.
    hga_c_init: float = 1.0
    hga_c_min: float = 0.001
    hga_c_max: float = 8.0
    hga_b_init_std: float = 1.0e-4

    # EMCA
    emca_c_work_init: float = 0.5
    emca_c_work_min: float = 0.01
    emca_c_work_max: float = 4.0
    projector_hidden: int = 4096

    # LLM
    llm_name: str = ""
    llm_dim: int = 3584
    freeze_llm: bool = True

    # LoRA (SFT stage only; ignored during align)
    lora: Optional[Dict[str, Any]] = None

    # SFT
    system_prompt: str = "You are a helpful assistant that analyzes audio content."
    sft_eval_ratio: float = 0.005

    # Training
    training: TrainingConfig = field(default_factory=TrainingConfig)

    # Data
    datasets: List[Dict[str, Any]] = field(default_factory=list)
    audio_path_prefix_map: Dict[str, str] = field(default_factory=dict)
    rich_annotation_fields: Dict[str, Dict[str, Any]] = field(default_factory=dict)

    # ---- Resume ----
    # resume_from:  CROSS-STAGE handoff. Loads HGA + EMCA weights ONLY from
    #               a bridge.pt; optimizer, scheduler, and global_step all
    #               start fresh. Typical use:
    #                   prealign  → align   :  prealign/final/bridge.pt
    #                   align     → SFT     :  align/final/bridge.pt
    # resume_state: SAME-STAGE seamless mid-run resume. Loads full training
    #               state (model + optimizer + scheduler + RNG + global_step)
    #               from an accelerator.save_state() directory. Use this when
    #               continuing the SAME stage after a crash or pause. Point
    #               it at either   outputs/<stage>/checkpoint-N/
    #               or             outputs/<stage>/checkpoint-N/state/
    # The two are mutually exclusive — resume_state takes precedence if
    # both are set (its model weights override anything resume_from would
    # have loaded).
    resume_from: Optional[str] = None
    resume_state: Optional[str] = None

    # Convenience properties (no setters; modify .training fields directly)
    @property
    def output_dir(self): return self.training.output_dir
    @property
    def batch_size(self): return self.training.batch_size
    @property
    def grad_accumulation_steps(self): return self.training.grad_accumulation_steps
    @property
    def max_audio_length(self): return self.training.max_audio_length
    @property
    def num_epochs(self): return self.training.num_epochs
    @property
    def max_steps(self): return self.training.max_steps
    @property
    def warmup_ratio(self): return self.training.warmup_ratio
    @property
    def learning_rate(self): return self.training.learning_rate
    @property
    def weight_decay(self): return self.training.weight_decay
    @property
    def gradient_clip_norm(self): return self.training.gradient_clip_norm
    @property
    def save_steps(self): return self.training.save_steps
    @property
    def logging_steps(self): return self.training.logging_steps

    @classmethod
    def from_yaml(cls, path: str) -> "ThinkerConfig":
        with open(path) as f:
            data = yaml.safe_load(f)
        return cls.from_dict(data)

    @classmethod
    def from_dict(cls, data: dict) -> "ThinkerConfig":
        training_raw = dict(data.get("training") or {})
        valid = {f.name for f in _dc.fields(TrainingConfig)}
        training_raw = {k: v for k, v in training_raw.items() if k in valid}
        training = TrainingConfig(**training_raw)

        valid_top = {f.name for f in _dc.fields(cls)} - {"training"}
        top = {k: v for k, v in data.items() if k in valid_top and k != "training"}
        return cls(training=training, **top)

    def to_yaml(self, path: str):
        d = asdict(self)
        os.makedirs(os.path.dirname(path) or ".", exist_ok=True)
        with open(path, "w") as f:
            yaml.safe_dump(d, f, sort_keys=False)