"""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//checkpoint-N/ # or outputs//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)