thinker/model.py

"""
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