modeling_hga_thinker.py

"""
HGA-Thinker HuggingFace-loadable wrapper.

This is a *thin* wrapper around the training-time `thinker.model.ThinkerModel`.
It does NOT reimplement the architecture — it imports the exact same modules
used during training, so the inference graph is byte-for-byte identical to what
produced the checkpoint.

Assembly order (mirrors thinker/train_sft.py main()):
    1. ThinkerModel(thinker_config)                # builds encoder(HGA) + EMCA
    2. AutoModelForCausalLM.from_pretrained(llm)   # bf16, trust_remote_code
       model.load_llm(llm)                         # freeze base
    3. load bridge.pt → hga_layers / emca / audio_start_embed / audio_end_embed
    4. model.setup_lora(lora_cfg)                  # wrap LLM as PeftModel
    5. PeftModel.load_adapter(lora/)               # load trained adapter weights

Step order matters: LoRA must be set up *after* bridge.pt is loaded (HGA/EMCA
are not LoRA-wrapped) and the adapter must be loaded into the already-LoRA-fied
LLM, exactly as training did.
"""
import os
import json
import logging
from typing import Optional, List, Union

import torch
import torch.nn as nn

from transformers import (
    PreTrainedModel,
    AutoModelForCausalLM,
    AutoTokenizer,
    WhisperFeatureExtractor,
)

from .configuration_hga_thinker import HGAThinkerConfig

logger = logging.getLogger(__name__)


def _bridge_config_from_hf(hf_cfg: HGAThinkerConfig, *, whisper_path, llm_name):
    """Build a `thinker.config.ThinkerConfig` from the HF config.

    Only the architecture fields ThinkerModel reads in __init__ are needed.
    Path fields are resolved by the caller (may be bundled sub-dirs).
    """
    from thinker.config import ThinkerConfig
    return ThinkerConfig(
        whisper_path=whisper_path,
        encoder_dim=hf_cfg.encoder_dim,
        num_whisper_layers=hf_cfg.num_whisper_layers,
        extract_layers=list(hf_cfg.extract_layers),
        target_frame_rate_hz=hf_cfg.target_frame_rate_hz,
        hga_c_init=hf_cfg.hga_c_init,
        hga_c_min=hf_cfg.hga_c_min,
        hga_c_max=hf_cfg.hga_c_max,
        hga_b_init_std=hf_cfg.hga_b_init_std,
        emca_c_work_init=hf_cfg.emca_c_work_init,
        emca_c_work_min=hf_cfg.emca_c_work_min,
        emca_c_work_max=hf_cfg.emca_c_work_max,
        projector_hidden=hf_cfg.projector_hidden,
        llm_name=llm_name,
        llm_dim=hf_cfg.llm_dim,
        freeze_llm=hf_cfg.freeze_llm,
    )


class HGAThinkerForConditionalGeneration(PreTrainedModel):
    """Standalone, from_pretrained-able HGA-Thinker speech LM."""

    config_class = HGAThinkerConfig
    base_model_prefix = "hga_thinker"

    def __init__(self, config: HGAThinkerConfig):
        super().__init__(config)
        # The real model is built in from_pretrained (needs external weights).
        # Direct __init__ is only used by HF internals; we build a stub.
        self.thinker = None
        self._tokenizer = None
        self._feature_extractor = None

    # ------------------------------------------------------------------
    # Loading
    # ------------------------------------------------------------------
    @classmethod
    def from_pretrained(cls, model_dir: str, *,
                        device: Optional[str] = None,
                        torch_dtype: Optional[torch.dtype] = None,
                        whisper_path: Optional[str] = None,
                        llm_name: Optional[str] = None,
                        **kwargs) -> "HGAThinkerForConditionalGeneration":
        """Load an exported HGA-Thinker directory.

        Args:
            model_dir: directory produced by export.py.
            device: e.g. "cuda" / "cuda:0" / "cpu". Default: cuda if available.
            torch_dtype: override config dtype.
            whisper_path / llm_name: override the paths recorded in config
                (useful if the base models moved since export).
        """
        hf_cfg = HGAThinkerConfig.from_pretrained(model_dir)

        # ---- resolve dtype ----
        if torch_dtype is None:
            dtype_str = getattr(hf_cfg, "torch_dtype", "bfloat16")
            if isinstance(dtype_str, torch.dtype):
                torch_dtype = dtype_str
            else:
                torch_dtype = {
                    "bfloat16": torch.bfloat16,
                    "float16": torch.float16,
                    "float32": torch.float32,
                }.get(str(dtype_str), torch.bfloat16)

        if device is None:
            device = "cuda" if torch.cuda.is_available() else "cpu"

        # ---- resolve base-model paths (bundled vs referenced) ----
        def _resolve(sub, cfg_val, override):
            if override is not None:
                return override
            cand = os.path.join(model_dir, sub)
            if os.path.isdir(cand):           # bundled
                return cand
            return cfg_val                    # external reference

        wh_path = _resolve("whisper", hf_cfg.whisper_path, whisper_path)
        # Whisper "path" may be just a preprocessor ref; encoder needs the full
        # model. If only preprocessor_config.json was copied, fall back to the
        # recorded path / override.
        if not (os.path.isdir(wh_path) and
                os.path.isfile(os.path.join(wh_path, "config.json"))):
            wh_path = whisper_path or hf_cfg.whisper_path
        llm_path = _resolve("llm", hf_cfg.llm_name, llm_name)

        # ---- 1. Build ThinkerModel (encoder + EMCA) ----
        thinker_cfg = _bridge_config_from_hf(
            hf_cfg, whisper_path=wh_path, llm_name=llm_path)
        from thinker.model import ThinkerModel
        thinker = ThinkerModel(thinker_cfg)

        # ---- 2. Load + attach LLM ----
        logger.info(f"[load] LLM from {llm_path} ({torch_dtype})")
        llm = AutoModelForCausalLM.from_pretrained(
            llm_path, torch_dtype=torch_dtype, trust_remote_code=True)
        thinker.load_llm(llm)

        # ---- 3. Load bridge.pt (HGA + EMCA + boundary embeds) ----
        bridge_path = os.path.join(model_dir, "bridge.pt")
        if not os.path.isfile(bridge_path):
            raise FileNotFoundError(f"bridge.pt not found in {model_dir}")
        state = torch.load(bridge_path, map_location="cpu", weights_only=False)
        m1, _ = thinker.encoder.hga_layers.load_state_dict(
            state["hga_layers"], strict=False)
        m2, _ = thinker.emca.load_state_dict(state["emca"], strict=False)
        if m1 or m2:
            logger.warning(f"[load] missing keys hga={m1} emca={m2}")
        if "audio_start_embed" in state:
            thinker.audio_start_embed.data.copy_(state["audio_start_embed"])
            thinker.audio_end_embed.data.copy_(state["audio_end_embed"])
        logger.info("[load] bridge.pt loaded (HGA + EMCA + boundary embeds)")

        # ---- 4 & 5. LoRA: load the trained adapter ----
        # We use PeftModel.from_pretrained rather than setup_lora() +
        # manual state_dict load. Reasons:
        #   * It reads lora/adapter_config.json and rebuilds the adapter
        #     structure exactly as it was saved (r, alpha, target_modules,
        #     inference_mode, peft_version-specific fields), so the export is
        #     robust to PEFT-version drift between training and inference.
        #   * It is the canonical PEFT load path, handling key remapping and
        #     inference_mode=True automatically.
        # This attaches the adapter onto the frozen base LLM that load_llm()
        # already set on thinker.llm — matching training, where LoRA also wraps
        # the same base LLM (the only difference being PeftModel.from_pretrained
        # vs get_peft_model, which produce equivalent inference graphs).
        if hf_cfg.has_lora:
            lora_dir = os.path.join(model_dir, "lora")
            if not (os.path.isdir(lora_dir) and os.path.isfile(
                    os.path.join(lora_dir, "adapter_config.json"))):
                raise FileNotFoundError(
                    f"config says has_lora=True but no valid lora/ in {model_dir}")
            from peft import PeftModel
            thinker.llm = PeftModel.from_pretrained(
                thinker.llm, lora_dir, is_trainable=False)
            logger.info("[load] LoRA adapter loaded via PeftModel.from_pretrained")

        # ---- finalize ----
        thinker.to(device=device, dtype=torch_dtype)
        thinker.eval()

        self = cls(hf_cfg)
        self.thinker = thinker
        self._device = device
        self._dtype = torch_dtype

        # processor pieces
        self._tokenizer = AutoTokenizer.from_pretrained(model_dir)
        self._feature_extractor = WhisperFeatureExtractor.from_pretrained(wh_path)
        return self

    # ------------------------------------------------------------------
    # Inference
    # ------------------------------------------------------------------
    @torch.no_grad()
    def chat(self,
             audio: Optional[Union[str, "torch.Tensor", List]] = None,
             query: str = "",
             *,
             processor=None,
             system_prompt: Optional[str] = None,
             max_new_tokens: int = 256,
             **gen_kwargs) -> Union[str, List[str]]:
        """Single-turn audio+text chat.

        Builds a one-message-per-role ChatML conversation in the exact shape
        ThinkerModel.generate_sft expects (role/parts/type), encodes the audio
        via WhisperFeatureExtractor, and runs greedy generation.

        `audio` may be a path, a (samples,) waveform tensor at 16k, or a list
        of those for a single multi-audio turn. Pass None for text-only.
        """
        assert self.thinker is not None, "Call from_pretrained first."
        tok = (processor.tokenizer if processor is not None
               else self._tokenizer)
        fe = (processor.feature_extractor if processor is not None
              else self._feature_extractor)
        sys_p = system_prompt or self.config.system_prompt

        # ---- load + featurize audio(s) ----
        audios = []
        if audio is not None:
            audios = audio if isinstance(audio, (list, tuple)) else [audio]
        mel_list, frames_list = [], []
        for a in audios:
            wav = _load_waveform(a, self.config.sample_rate,
                                 self.config.max_audio_length)
            mel = fe(wav.numpy(), sampling_rate=self.config.sample_rate,
                     return_tensors="pt").input_features[0]
            mel_list.append(mel)
            frames_list.append(min(len(wav) // 160,  # 10ms hops
                                   int(self.config.max_audio_length * 100)))

        if mel_list:
            mel_inputs = torch.stack(mel_list).to(
                device=self._device, dtype=self._dtype)
            audio_frames = torch.tensor(frames_list, device=self._device)
        else:
            mel_inputs = torch.empty(0, device=self._device, dtype=self._dtype)
            audio_frames = None

        # ---- build conversation in generate_sft's expected schema ----
        user_parts = []
        for i in range(len(audios)):
            user_parts.append({"type": "audio", "audio_index": i})
        if query:
            user_parts.append({"type": "text", "content": query})

        conversation = [
            {"role": "system", "parts": [{"type": "text", "content": sys_p}]},
            {"role": "user", "parts": user_parts},
            {"role": "assistant", "parts": []},   # prefix-only in gen mode
        ]

        results = self.thinker.generate_sft(
            mel_inputs=mel_inputs,
            audio_counts=[len(audios)],
            conversations=[conversation],
            tokenizer=tok,
            max_new_tokens=max_new_tokens,
            audio_frames=audio_frames,
            **gen_kwargs,
        )
        return results[0] if results else ""

    # convenience accessors
    @property
    def tokenizer(self):
        return self._tokenizer

    @property
    def feature_extractor(self):
        return self._feature_extractor


# ----------------------------------------------------------------------
# Helpers
# ----------------------------------------------------------------------
def _load_waveform(audio, sample_rate: int, max_seconds: float) -> torch.Tensor:
    """Return a mono float32 waveform tensor at `sample_rate`, truncated."""
    if isinstance(audio, torch.Tensor):
        wav = audio.float()
        if wav.dim() > 1:
            wav = wav.mean(dim=0)
    else:
        import torchaudio
        wav, sr = torchaudio.load(audio)
        if wav.dim() > 1:
            wav = wav.mean(dim=0)
        if sr != sample_rate:
            wav = torchaudio.functional.resample(wav, sr, sample_rate)
        wav = wav.float()
    max_len = int(max_seconds * sample_rate)
    if wav.numel() > max_len:
        wav = wav[:max_len]
    return wav


class HGAThinkerProcessor:
    """Bundles the Qwen tokenizer + Whisper feature extractor.

    Mirrors what training used: AutoTokenizer(llm) + WhisperFeatureExtractor(whisper).
    """
    def __init__(self, tokenizer, feature_extractor, config: dict = None):
        self.tokenizer = tokenizer
        self.feature_extractor = feature_extractor
        self.config = config or {}

    @classmethod
    def from_pretrained(cls, model_dir: str, *, whisper_path: Optional[str] = None):
        tok = AutoTokenizer.from_pretrained(model_dir)
        # whisper ref: bundled dir, else preprocessor_config.json at root, else override
        wh = whisper_path
        if wh is None:
            bundled = os.path.join(model_dir, "whisper")
            wh = bundled if os.path.isdir(bundled) else model_dir
        fe = WhisperFeatureExtractor.from_pretrained(wh)
        proc_cfg = {}
        pc = os.path.join(model_dir, "processor_config.json")
        if os.path.isfile(pc):
            with open(pc) as f:
                proc_cfg = json.load(f)
        return cls(tok, fe, proc_cfg)