""" HGA-Thinker Model. Architecture: HGAWhisperEncoder (frozen Whisper + HGA on all 32 layers Q/K/V) → extract 8 scale features → mean-pool to target frame rate EMCA (Poincaré ball cross-attention fusion) → p_fuse (for L_radius) → log_map → projector → RMSNorm → audio_tokens Frozen Qwen 7B LLM → [audio_tokens, text_embeds] → L_CE SFT extensions (appended, align code untouched): setup_lora() — add LoRA to frozen LLM get_sft_param_groups — three groups: LoRA / EMCA / HGA forward_sft() — multi-audio + conversation-based input generate_sft() — multi-audio generation """ import math import logging from typing import Dict, Any, Optional, List, Tuple import torch import torch.nn as nn import torch.nn.functional as F logger = logging.getLogger(__name__) class ThinkerModel(nn.Module): """HGA-Thinker: Whisper(HGA) → EMCA → Bridge → frozen LLM.""" def __init__(self, config): super().__init__() self.config = config # 1. Whisper encoder with HGA from .encoder import HGAWhisperEncoder self.encoder = HGAWhisperEncoder( model_path=config.whisper_path, extract_layers=config.extract_layers, num_encoder_layers=config.num_whisper_layers, hga_c_init=config.hga_c_init, hga_c_min=config.hga_c_min, hga_c_max=config.hga_c_max, hga_b_init_std=config.hga_b_init_std, ) # 2. EMCA from .emca import EMCA self.emca = EMCA( encoder_dim=config.encoder_dim, llm_dim=config.llm_dim, num_scales=len(config.extract_layers), c_work_init=config.emca_c_work_init, c_work_min=config.emca_c_work_min, c_work_max=config.emca_c_work_max, projector_hidden=config.projector_hidden, ) # 3. LLM (loaded externally) self.llm = None self.target_frame_rate_hz = config.target_frame_rate_hz # Audio boundary markers for multi-audio SFT. # Learnable embeddings inserted before / after each audio token # sequence so the LLM can distinguish separate audio inputs. # Dimensions match llm_dim; initialised with small random values # (std=0.02, same as typical transformer embedding init). # They are part of the bridge (not the frozen LLM), so they are # naturally trainable and saved in bridge.pt. self.audio_start_embed = nn.Parameter(torch.randn(config.llm_dim) * 0.02) self.audio_end_embed = nn.Parameter(torch.randn(config.llm_dim) * 0.02) def load_llm(self, llm_model): self.llm = llm_model if self.config.freeze_llm: for p in self.llm.parameters(): p.requires_grad = False def trainable_parameters(self): return [p for p in self.parameters() if p.requires_grad] def count_trainable_parameters(self) -> int: return sum(p.numel() for p in self.parameters() if p.requires_grad) def get_param_groups(self, base_lr: float, hga_lr_scale: float = 1.0, emca_lr_scale: float = 1.0): hga_ids = set(id(p) for p in self.encoder.hga_layers.parameters()) emca_ids = set(id(p) for p in self.emca.parameters()) hga_params, emca_params, other_params = [], [], [] for p in self.parameters(): if not p.requires_grad: continue pid = id(p) if pid in hga_ids: hga_params.append(p) elif pid in emca_ids: emca_params.append(p) else: other_params.append(p) groups = [] if hga_params: groups.append({"params": hga_params, "lr": base_lr * hga_lr_scale, "_group_name": "hga"}) if emca_params: groups.append({"params": emca_params, "lr": base_lr * emca_lr_scale, "_group_name": "emca"}) if other_params: groups.append({"params": other_params, "lr": base_lr, "_group_name": "other"}) return groups # ---- Time-axis pooling ---- @staticmethod def _pool_time(x, in_rate, target_rate): if abs(in_rate - target_rate) < 1e-6: return x k = max(1, int(round(in_rate / target_rate))) B, T, D = x.shape T_new = T // k if T_new == 0: return x.mean(dim=1, keepdim=True) return x[:, :T_new * k, :].reshape(B, T_new, k, D).mean(dim=2) # ============================================================ # Align forward (unchanged) # ============================================================ def get_audio_tokens(self, mel_input, audio_frames=None): multi_scale = self.encoder(mel_input) in_rate = self.encoder.output_frame_rate_hz pooled = [self._pool_time(f, in_rate, self.target_frame_rate_hz) for f in multi_scale] emca_out = self.emca(pooled) audio_tokens = emca_out["audio_tokens"] B, T_audio, _ = audio_tokens.shape audio_token_mask = None if audio_frames is not None: ratio = 50.0 / self.target_frame_rate_hz valid = torch.ceil(audio_frames.float() / ratio).long() audio_token_mask = ( torch.arange(T_audio, device=audio_tokens.device).unsqueeze(0) < valid.unsqueeze(1) ).long() return { "audio_tokens": audio_tokens, "audio_token_mask": audio_token_mask, "radii_per_scale": emca_out["radii_per_scale"], "c_work": emca_out["c_work"], "scale_weights": emca_out["scale_weights"], "scale_entropy": emca_out["scale_entropy"], "attention_temp": emca_out["attention_temp"], } def forward(self, mel_input=None, text_input_ids=None, text_attention_mask=None, labels=None, audio_frames=None, **kwargs): assert self.llm is not None, "Call load_llm() first." bridge_out = self.get_audio_tokens(mel_input, audio_frames) llm_dtype = next(self.llm.parameters()).dtype audio_tokens = bridge_out["audio_tokens"].to(dtype=llm_dtype) B, T_audio, _ = audio_tokens.shape text_embeds = self.llm.get_input_embeddings()(text_input_ids) inputs_embeds = torch.cat([audio_tokens, text_embeds], dim=1) atm = bridge_out.get("audio_token_mask") audio_mask = atm if atm is not None else torch.ones( B, T_audio, device=audio_tokens.device, dtype=torch.long) full_mask = torch.cat([audio_mask, text_attention_mask], dim=1) \ if text_attention_mask is not None else \ torch.ones(B, inputs_embeds.shape[1], device=audio_tokens.device, dtype=torch.long) if labels is not None: audio_labels = torch.full((B, T_audio), -100, device=labels.device, dtype=labels.dtype) full_labels = torch.cat([audio_labels, labels], dim=1) else: full_labels = None llm_out = self.llm(inputs_embeds=inputs_embeds, attention_mask=full_mask, labels=full_labels, return_dict=True) bridge_out["lm_loss"] = llm_out.loss bridge_out["logits"] = llm_out.logits return bridge_out @torch.no_grad() def generate(self, mel_input=None, prompt_input_ids=None, prompt_attention_mask=None, max_new_tokens=256, audio_frames=None, **kwargs): assert self.llm is not None was_training = self.training self.eval() bridge_out = self.get_audio_tokens(mel_input, audio_frames) llm_dtype = next(self.llm.parameters()).dtype audio_tokens = bridge_out["audio_tokens"].to(dtype=llm_dtype) B, T_audio, _ = audio_tokens.shape prompt_embeds = self.llm.get_input_embeddings()(prompt_input_ids) inputs_embeds = torch.cat([audio_tokens, prompt_embeds], dim=1) atm = bridge_out.get("audio_token_mask") audio_mask = atm if atm is not None else torch.ones( B, T_audio, device=audio_tokens.device, dtype=torch.long) full_mask = torch.cat([audio_mask, prompt_attention_mask], dim=1) \ if prompt_attention_mask is not None else \ torch.ones(B, inputs_embeds.shape[1], device=audio_tokens.device, dtype=torch.long) default_eos = getattr(self.llm.generation_config, "eos_token_id", None) if default_eos is None: default_eos = self.llm.config.eos_token_id if isinstance(default_eos, int): default_eos = [default_eos] gen_kwargs = dict(inputs_embeds=inputs_embeds, attention_mask=full_mask, max_new_tokens=max_new_tokens, do_sample=False, eos_token_id=default_eos, pad_token_id=default_eos[0] if default_eos else 0) gen_kwargs.update(kwargs) result = self.llm.generate(**gen_kwargs) if was_training: self.train() return result # ============================================================ # SFT extensions # ============================================================ def setup_lora(self, lora_config: Dict): """Add LoRA adapters to the frozen LLM for SFT.""" try: from peft import get_peft_model, LoraConfig, TaskType except ImportError: raise ImportError("pip install peft (required for SFT LoRA)") default_targets = ["q_proj", "k_proj", "v_proj", "o_proj", "gate_proj", "up_proj", "down_proj"] cfg = LoraConfig( r=lora_config.get("r", 32), lora_alpha=lora_config.get("lora_alpha", 64), target_modules=lora_config.get("target_modules", default_targets), lora_dropout=lora_config.get("lora_dropout", 0.05), bias=lora_config.get("bias", "none"), task_type=TaskType.CAUSAL_LM, ) logger.info(f"[LoRA] r={cfg.r}, alpha={cfg.lora_alpha}, " f"targets={cfg.target_modules}") self.llm = get_peft_model(self.llm, cfg) self.llm.print_trainable_parameters() self._lora_config = cfg def get_sft_param_groups(self, base_lr: float, hga_lr_scale: float = 0.3, emca_lr_scale: float = 0.5): hga_ids = set(id(p) for p in self.encoder.hga_layers.parameters()) emca_ids = set(id(p) for p in self.emca.parameters()) hga_p, emca_p, lora_p = [], [], [] for p in self.parameters(): if not p.requires_grad: continue pid = id(p) if pid in hga_ids: hga_p.append(p) elif pid in emca_ids: emca_p.append(p) else: lora_p.append(p) groups = [] if lora_p: groups.append({"params": lora_p, "lr": base_lr, "_group_name": "lora"}) if emca_p: groups.append({"params": emca_p, "lr": base_lr * emca_lr_scale, "_group_name": "emca"}) if hga_p: groups.append({"params": hga_p, "lr": base_lr * hga_lr_scale, "_group_name": "hga"}) for g in groups: n = sum(p.numel() for p in g["params"]) logger.info(f" SFT group [{g['_group_name']}]: " f"{n:,} params, lr={g['lr']:.2e}") return groups # ---- multi-audio encoding ---- def encode_audio_batch(self, mel_inputs, audio_frames=None): if mel_inputs is None or mel_inputs.numel() == 0: return [], None bridge = self.get_audio_tokens(mel_inputs, audio_frames) tokens = bridge["audio_tokens"] radii = bridge.get("radii_per_scale") return [tokens[i] for i in range(tokens.shape[0])], radii # ---- SFT forward ---- def forward_sft(self, mel_inputs, audio_counts, conversations, tokenizer, audio_frames=None): assert self.llm is not None, "Call load_llm() first." device = next(self.llm.parameters()).device llm_dtype = next(self.llm.parameters()).dtype batch_size = len(conversations) has_audio = (mel_inputs is not None and mel_inputs.numel() > 0) if has_audio: all_tokens, radii = self.encode_audio_batch(mel_inputs, audio_frames) else: all_tokens, radii = [], None offset = 0 per_sample_tokens = [] for cnt in audio_counts: per_sample_tokens.append( [t.to(dtype=llm_dtype) for t in all_tokens[offset:offset + cnt]]) offset += cnt embed_fn = self.llm.get_input_embeddings() all_embeds, all_labels = [], [] for i in range(batch_size): e, l = self._build_sft_sample( conversations[i], per_sample_tokens[i], tokenizer, embed_fn, device, llm_dtype, generation_mode=False) all_embeds.append(e) all_labels.append(l) if not all_embeds: dummy = torch.tensor(0.0, device=device, requires_grad=True) return {"lm_loss": dummy, "radii_per_scale": radii, "c_work": torch.tensor(0.0, device=device), "scale_entropy": torch.tensor(0.0, device=device)} max_len = max(e.shape[0] for e in all_embeds) pad_embeds, pad_masks, pad_labels = [], [], [] for e, l in zip(all_embeds, all_labels): seq_len = e.shape[0] gap = max_len - seq_len if gap > 0: e = torch.cat([e, torch.zeros(gap, e.shape[-1], device=device, dtype=llm_dtype)]) l = torch.cat([l, torch.full((gap,), -100, device=device, dtype=torch.long)]) amask = torch.cat([ torch.ones(seq_len, device=device, dtype=torch.long), torch.zeros(gap, device=device, dtype=torch.long), ]) if gap > 0 else torch.ones(max_len, device=device, dtype=torch.long) pad_embeds.append(e) pad_masks.append(amask) pad_labels.append(l) llm_out = self.llm( inputs_embeds=torch.stack(pad_embeds), attention_mask=torch.stack(pad_masks), labels=torch.stack(pad_labels), return_dict=True) return { "lm_loss": llm_out.loss, "logits": llm_out.logits, "radii_per_scale": radii, "c_work": self.emca.c_work().detach() if radii is not None else torch.tensor(0.0, device=device), "scale_entropy": torch.tensor(0.0, device=device), } # ---- build one sample ---- def _build_sft_sample(self, conversation, audio_tokens, tokenizer, embed_fn, device, dtype, generation_mode=False): """Build input embeds + labels for one SFT sample. generation_mode=True: emit only up to the assistant prefix (<|im_start|>assistant\\n), then stop. No response text, no <|im_end|>. """ segs_e, segs_l = [], [] n_aud = len(audio_tokens) def _tok(text): return tokenizer.encode(text, add_special_tokens=False) def _embed(ids): return embed_fn(torch.tensor(ids, device=device, dtype=torch.long)) def _text_parts(parts): return "".join( p.get("content", "") or p.get("text", "") for p in parts if p.get("type") == "text") for msg in conversation: role = msg.get("role", "") parts = msg.get("parts", []) if role == "system": txt = _text_parts(parts) ids = _tok(f"<|im_start|>system\n{txt}<|im_end|>\n") if ids: segs_e.append(_embed(ids)) segs_l.extend([-100] * len(ids)) elif role == "user": pre = _tok("<|im_start|>user\n") if pre: segs_e.append(_embed(pre)) segs_l.extend([-100] * len(pre)) for p in parts: pt = p.get("type", "") if pt == "audio": idx = p.get("audio_index", -1) if 0 <= idx < n_aud: at = audio_tokens[idx] # Boundary markers: <|audio_start|> ... <|audio_end|> segs_e.append(self.audio_start_embed.unsqueeze(0).to(dtype=dtype)) segs_l.append(-100) segs_e.append(at) segs_l.extend([-100] * at.shape[0]) segs_e.append(self.audio_end_embed.unsqueeze(0).to(dtype=dtype)) segs_l.append(-100) elif pt == "text": txt = p.get("content", "") or p.get("text", "") if txt: ids = _tok(txt) if ids: segs_e.append(_embed(ids)) segs_l.extend([-100] * len(ids)) suf = _tok("<|im_end|>\n") if suf: segs_e.append(_embed(suf)) segs_l.extend([-100] * len(suf)) elif role == "assistant": # Standard ChatML assistant prefix (no thinking placeholder) pre = _tok("<|im_start|>assistant\n") if pre: segs_e.append(_embed(pre)) segs_l.extend([-100] * len(pre)) # ---- generation_mode: STOP HERE ---- # No response text, no <|im_end|>. # LLM continues generating from this point. if generation_mode: break # Training mode: add response (compute loss) + eos txt = _text_parts(parts) if txt: resp_ids = _tok(txt) if resp_ids: segs_e.append(_embed(resp_ids)) segs_l.extend(resp_ids) eos = _tok("<|im_end|>") if eos: segs_e.append(_embed(eos)) segs_l.extend(eos) if not segs_e: placeholder = _embed([tokenizer.pad_token_id or 0]) return placeholder, torch.tensor([-100], device=device, dtype=torch.long) return (torch.cat(segs_e, dim=0), torch.tensor(segs_l, device=device, dtype=torch.long)) # ---- SFT generate ---- @torch.no_grad() def generate_sft(self, mel_inputs, audio_counts, conversations, tokenizer, max_new_tokens=256, audio_frames=None, **kwargs): assert self.llm is not None was_training = self.training self.eval() device = next(self.llm.parameters()).device llm_dtype = next(self.llm.parameters()).dtype if mel_inputs is not None and mel_inputs.numel() > 0: all_tokens, _ = self.encode_audio_batch(mel_inputs, audio_frames) else: all_tokens = [] offset = 0 per_sample = [] for cnt in audio_counts: per_sample.append( [t.to(dtype=llm_dtype) for t in all_tokens[offset:offset + cnt]]) offset += cnt embed_fn = self.llm.get_input_embeddings() results = [] for i, conv in enumerate(conversations): # generation_mode=True → stops after assistant prefix, # no <|im_end|>, model continues generating. e, _ = self._build_sft_sample( conv, per_sample[i], tokenizer, embed_fn, device, llm_dtype, generation_mode=True) embeds = e.unsqueeze(0) mask = torch.ones(1, embeds.shape[1], device=device, dtype=torch.long) default_eos = getattr(self.llm.generation_config, "eos_token_id", None) if default_eos is None: default_eos = getattr(self.llm.config, "eos_token_id", None) if isinstance(default_eos, int): default_eos = [default_eos] gen_kwargs = dict( inputs_embeds=embeds, attention_mask=mask, max_new_tokens=max_new_tokens, do_sample=False, eos_token_id=default_eos, pad_token_id=default_eos[0] if default_eos else 0) gen_kwargs.update(kwargs) gen_ids = self.llm.generate(**gen_kwargs) text = tokenizer.decode(gen_ids[0], skip_special_tokens=True) results.append(text) if was_training: self.train() return results