Upload vibevoice_surgery (2).py

vibevoice_surgery (2).py

@@ -0,0 +1,1992 @@
+"""
+vibevoice_surgery.py - VibeVoice 1.5B -> 4B Model Surgery Library
+==================================================================
+
+Surgically replaces the LLM layer of VibeVoice-1.5B (Qwen2.5-1.5B,
+hidden_size=1536) with Qwen/Qwen3.5-4B-Base text decoder
+(hidden_size=2560), while EXPANDING the diffusion head and the
+acoustic/semantic connectors from 1536 -> 2560 with knowledge-preserving
+Zero-Init Padding (ZIP).
+
+ARCHITECTURE SNAPSHOT
+---------------------
+Original VibeVoice-1.5B (`VibeVoiceForConditionalGeneration`):
+    model.language_model         : Qwen2Model      (hidden=1536, 28 layers)
+    model.acoustic_connector     : SpeechConnector (64   -> 1536 -> 1536)
+    model.semantic_connector     : SpeechConnector (128  -> 1536 -> 1536)
+    model.prediction_head        : VibeVoiceDiffusionHead (hidden=1536, latent=64)
+    model.acoustic_tokenizer     : CNN (frozen, independent of LLM hidden)
+    model.semantic_tokenizer     : CNN (frozen, independent of LLM hidden)
+    lm_head                      : Linear(1536 -> 151936, tied to embed_tokens)
+
+Target VibeVoice-4B (after surgery):
+    model.language_model         : Qwen3_5TextModel (hidden=2560, 32 layers, hybrid)
+    model.acoustic_connector     : SpeechConnector  (64   -> 2560 -> 2560)  [ZIP]
+    model.semantic_connector     : SpeechConnector  (128  -> 2560 -> 2560)  [ZIP]
+    model.prediction_head        : VibeVoiceDiffusionHead (hidden=2560, latent=64) [ZIP]
+    model.acoustic_tokenizer     : unchanged
+    model.semantic_tokenizer     : unchanged
+    lm_head                      : Linear(2560 -> 248320, tied to new embed_tokens)
+
+ZERO-INIT PADDING (ZIP) — KNOWLEDGE PRESERVATION STRATEGY
+---------------------------------------------------------
+For every linear layer being expanded we use the following rules so that
+the surgered model produces *almost* the same output as the original at
+init time (the new hidden dims contribute zero), giving us a stable
+starting point for fine-tuning:
+
+  * Linear expanded on output dim only (input unchanged):
+        W_new[:old_out, :]            = W_old          (preserve)
+        W_new[old_out:, :]            = 0              (silent new outputs)
+        b_new[:old_out]               = b_old          (preserve)
+        b_new[old_out:]               = 0              (silent)
+
+  * Linear expanded on input dim only (output unchanged):
+        W_new[:, :old_in]             = W_old          (preserve old input weights)
+        W_new[:, old_in:]             = 0              (ignore new input dims)
+
+  * Linear expanded on BOTH input & output:
+        W_new[:old_out, :old_in]      = W_old          (preserve block)
+        W_new[:old_out, old_in:]      = 0              (ignore new inputs)
+        W_new[old_out:, :]            = 0              (silent new outputs)
+
+  * RMSNorm / LayerNorm expanded:
+        W_new[:old_dim]               = W_old          (preserve)
+        W_new[old_dim:]               = 1.0            (identity for new dims)
+
+  * TimestepEmbedder first linear (random-init layer):
+        W_new[:old_out, :]            = W_old          (preserve)
+        W_new[old_out:, :]            = N(0, 0.02)     (small noise for fresh capacity)
+
+  * adaLN modulation layers (originally zero-init in DiffusionHead):
+        W_new[:, :]                   = 0              (must remain zero to preserve
+                                                       identity behavior at start)
+
+  * final_layer.linear (originally zero-init):
+        W_new[:, :old_in]             = 0              (already zero, keep zero)
+        W_new[:, old_in:]             = 0              (also zero)
+
+This means at init time the surgered model:
+  - Produces zeros in the new output dims  [1536:2560] of every connector
+  - Ignores the new LLM hidden dims       [1536:2560] of every consumer
+  - Behaves like the original on the first 1536 dims of every flow
+After a brief fine-tune the new capacity becomes useful.
+
+HARD CONSTRAINTS
+----------------
+- Run on Kaggle with 2x T4 (16GB each, 32GB total VRAM) + 30GB RAM.
+- Surgery itself runs on CPU to avoid GPU OOM (no autograd needed).
+- All weights kept in bfloat16 to fit in RAM.
+- The Qwen3.5-4B-Base checkpoint is multimodal (Qwen3_5ForConditionalGeneration).
+  We extract only the text decoder (`.language_model.model`) and discard
+  vision + MTP heads.
+"""
+
+from __future__ import annotations
+
+import importlib
+import importlib.util
+import json
+import math
+import os
+import sys
+import shutil
+import traceback
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Tuple, Union
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+
+# =========================================================================== #
+#  CONSTANTS — captured from the actual configs                                #
+# =========================================================================== #
+
+# Original VibeVoice-1.5B (Qwen2.5-1.5B as LLM)
+OLD_HIDDEN_SIZE: int = 1536
+OLD_NUM_LAYERS: int = 28
+OLD_VOCAB_SIZE: int = 151936
+OLD_INTERMEDIATE_SIZE: int = 8960
+OLD_LLM_MODEL_TYPE: str = "qwen2"
+
+# New Qwen3.5-4B-Base text decoder
+NEW_HIDDEN_SIZE: int = 2560
+NEW_NUM_LAYERS: int = 32
+NEW_VOCAB_SIZE: int = 248320
+NEW_INTERMEDIATE_SIZE: int = 9216
+NEW_LLM_MODEL_TYPE: str = "qwen3_5_text"
+
+# Diffusion-head constants (unchanged by surgery)
+DIFFUSION_LATENT_SIZE: int = 64
+DIFFUSION_HEAD_LAYERS: int = 4
+DIFFUSION_HEAD_FFN_RATIO: float = 3.0
+# After expansion: 2560 * 3.0 = 7680
+NEW_DIFFUSION_FFN_DIM: int = int(NEW_HIDDEN_SIZE * DIFFUSION_HEAD_FFN_RATIO)
+OLD_DIFFUSION_FFN_DIM: int = int(OLD_HIDDEN_SIZE * DIFFUSION_HEAD_FFN_RATIO)
+
+# Acoustic / Semantic tokenizer dims (unchanged)
+ACOUSTIC_VAE_DIM: int = 64
+SEMANTIC_VAE_DIM: int = 128
+
+# Default HF model IDs
+DEFAULT_VIBEVOICE_PATH: str = "microsoft/VibeVoice-1.5B"
+DEFAULT_QWEN35_PATH: str = "Qwen/Qwen3.5-4B-Base"
+
+# Default dtype for everything
+DEFAULT_DTYPE: torch.dtype = torch.bfloat16
+
+
+# =========================================================================== #
+#  LOGGER                                                                      #
+# =========================================================================== #
+
+class _Logger:
+    """Tiny logger that prints with a [surgery] prefix and flushes."""
+    def __init__(self, verbose: bool = True):
+        self.verbose = verbose
+
+    def info(self, msg: str):
+        if self.verbose:
+            print(f"[surgery][INFO] {msg}", flush=True)
+
+    def warn(self, msg: str):
+        print(f"[surgery][WARN] {msg}", flush=True)
+
+    def error(self, msg: str):
+        print(f"[surgery][ERROR] {msg}", flush=True)
+
+    def section(self, title: str):
+        if self.verbose:
+            bar = "=" * 70
+            print(f"\n{bar}\n[surgery] {title}\n{bar}", flush=True)
+
+
+log = _Logger(verbose=True)
+
+
+# =========================================================================== #
+#  DATA CLASSES                                                                #
+# =========================================================================== #
+
+@dataclass
+class SurgeryConfig:
+    """Configuration for the model surgery procedure."""
+    # Model paths / IDs
+    vibevoice_path: str = DEFAULT_VIBEVOICE_PATH
+    qwen35_path: str = DEFAULT_QWEN35_PATH
+    output_dir: str = "/home/z/my-project/download/vibevoice-4b-surgered"
+
+    # Path to a local clone of microsoft/VibeVoice (needed for custom code)
+    vibevoice_repo_path: str = "/home/z/my-project/repos/VibeVoice"
+
+    # Dtype
+    dtype: torch.dtype = DEFAULT_DTYPE
+
+    # Device for loading (CPU is safest for surgery)
+    load_device: str = "cpu"
+
+    # Whether to actually download weights (set False for dry-run / mock test)
+    download_weights: bool = True
+
+    # Whether to verify forward pass after surgery
+    verify_forward: bool = True
+
+    # Max parameter print during inspection
+    inspect_max_params: int = 25
+
+    # Random seed for reproducible init of new capacity
+    seed: int = 42
+
+
+@dataclass
+class SurgeryReport:
+    """Report produced by the surgery procedure."""
+    success: bool = False
+    original_param_count: int = 0
+    new_param_count: int = 0
+    llm_param_count: int = 0
+    diffusion_head_param_count: int = 0
+    connector_param_count: int = 0
+    preserved_param_count: int = 0  # weights copied from old model
+    new_param_count_only: int = 0   # weights that are new capacity
+    output_path: Optional[str] = None
+    errors: List[str] = field(default_factory=list)
+    warnings: List[str] = field(default_factory=list)
+
+    def summary(self) -> str:
+        lines = [
+            "Surgery Report",
+            "--------------",
+            f"  Success                    : {self.success}",
+            f"  Original total params      : {self.original_param_count:,}",
+            f"  New total params           : {self.new_param_count:,}",
+            f"    - LLM (Qwen3.5 text)     : {self.llm_param_count:,}",
+            f"    - Diffusion head         : {self.diffusion_head_param_count:,}",
+            f"    - Connectors             : {self.connector_param_count:,}",
+            f"  Preserved (copied) weights : {self.preserved_param_count:,}",
+            f"  New capacity weights       : {self.new_param_count_only:,}",
+        ]
+        if self.output_path:
+            lines.append(f"  Output path                : {self.output_path}")
+        if self.warnings:
+            lines.append(f"  Warnings ({len(self.warnings)}):")
+            for w in self.warnings:
+                lines.append(f"    - {w}")
+        if self.errors:
+            lines.append(f"  Errors ({len(self.errors)}):")
+            for e in self.errors:
+                lines.append(f"    - {e}")
+        return "\n".join(lines)
+
+
+# =========================================================================== #
+#  1.  VIBEVOICE LOADER                                                        #
+#  transformers doesn't know VibeVoice natively — we must register it         #
+#  by importing the modeling file from the cloned repo.                       #
+# =========================================================================== #
+
+def ensure_vibevoice_importable(repo_path: str) -> None:
+    """
+    Make the `vibevoice` package importable by adding its parent dir to
+    sys.path, then importing the modeling modules so that AutoModel
+    registration kicks in.
+
+    The microsoft/VibeVoice repo is structured as:
+        VibeVoice/
+        ├── vibevoice/
+        │   ├── __init__.py            (only imports streaming variant)
+        │   ├── modular/
+        │   │   ├── __init__.py        (only imports streaming variant)
+        │   │   ├── modeling_vibevoice.py            <-- we need this
+        │   │   ├── configuration_vibevoice.py       <-- we need this
+        │   │   ├── modular_vibevoice_diffusion_head.py
+        │   │   ├── modular_vibevoice_tokenizer.py
+        │   │   └── ...
+        │   └── ...
+        └── ...
+    """
+    repo_path = os.path.abspath(repo_path)
+    if not os.path.isdir(repo_path):
+        raise FileNotFoundError(
+            f"VibeVoice repo not found at {repo_path}. "
+            f"Clone it first: git clone https://github.com/microsoft/VibeVoice.git"
+        )
+
+    if repo_path not in sys.path:
+        sys.path.insert(0, repo_path)
+        log.info(f"Added VibeVoice repo to sys.path: {repo_path}")
+
+    # Force-(re)import the modeling file so AutoModel.register() runs.
+    # We import the modeling module directly (not via vibevoice.__init__)
+    # because __init__ only loads the streaming variant.
+    try:
+        # These imports trigger AutoModel.register(VibeVoiceConfig, ...)
+        # and AutoModelForCausalLM.register(VibeVoiceConfig, ...)
+        from vibevoice.modular import configuration_vibevoice  # noqa: F401
+        from vibevoice.modular import modeling_vibevoice       # noqa: F401
+        # Also import the tokenizer & diffusion head modules so AutoModel
+        # knows about VibeVoiceDiffusionHead and the tokenizer models.
+        from vibevoice.modular import modular_vibevoice_diffusion_head  # noqa: F401
+        from vibevoice.modular import modular_vibevoice_tokenizer       # noqa: F401
+        log.info("VibeVoice modeling modules imported successfully.")
+    except Exception as e:
+        log.error(f"Failed to import VibeVoice modeling modules: {e}")
+        log.error(traceback.format_exc())
+        raise
+
+
+def load_vibevoice_original(
+    model_path: str,
+    repo_path: str,
+    dtype: torch.dtype = DEFAULT_DTYPE,
+    device: str = "cpu",
+    download: bool = True,
+) -> "VibeVoiceForConditionalGeneration":
+    """
+    Load the original microsoft/VibeVoice-1.5B model.
+
+    Uses transformers' AutoModelForCausalLM after registering the VibeVoice
+    custom classes (done by ensure_vibevoice_importable).
+
+    Args:
+        model_path: HF model ID or local path
+        repo_path:  Local clone of microsoft/VibeVoice (for custom code)
+        dtype:      torch dtype (bfloat16 recommended)
+        device:     'cpu' or 'cuda' (CPU recommended for surgery)
+        download:   If False, only attempt local load (no HF download)
+    """
+    ensure_vibevoice_importable(repo_path)
+
+    from transformers import AutoModelForCausalLM, AutoConfig
+
+    log.info(f"Loading VibeVoice config from: {model_path}")
+    config = AutoConfig.from_pretrained(model_path, trust_remote_code=True)
+
+    log.info(f"Loading VibeVoice weights (dtype={dtype}, device={device})...")
+    kwargs = dict(
+        config=config,
+        trust_remote_code=True,
+        torch_dtype=dtype,
+        low_cpu_mem_usage=True,
+    )
+    if device == "cpu":
+        kwargs["device_map"] = {"": "cpu"}
+    else:
+        kwargs["device_map"] = "auto"
+
+    if not download:
+        # Local-only mode for testing
+        kwargs["local_files_only"] = True
+
+    model = AutoModelForCausalLM.from_pretrained(model_path, **kwargs)
+    model.eval()
+    log.info(f"VibeVoice loaded. param count = {sum(p.numel() for p in model.parameters()):,}")
+    return model
+
+
+# =========================================================================== #
+#  2.  QWEN3.5 LOADER                                                          #
+#  Qwen3.5-4B-Base is multimodal (Qwen3_5ForConditionalGeneration).           #
+#  We extract only the text decoder.                                          #
+# =========================================================================== #
+
+def _find_text_submodule(qwen35_model: nn.Module) -> Tuple[nn.Module, str]:
+    """
+    Walk the Qwen3.5 multimodal model to find the text decoder submodule.
+
+    Returns (text_module, attr_path) where attr_path is a dotted attribute
+    path like "language_model.model" that can be used with getattr().
+
+    The expected structure of Qwen3_5ForConditionalGeneration is:
+        Qwen3_5ForConditionalGeneration
+        ├── visual                         (vision encoder — discard)
+        ├── language_model                 (Qwen3_5TextForCausalLM)
+        │   ├── model                      (Qwen3_5TextModel — KEEP)
+        │   │   ├── embed_tokens
+        │   │   └── layers
+        │   └── lm_head (tied)
+        └── mtp_layer                      (Multi-Token Prediction — discard)
+
+    We want `language_model.model` (the base text model without lm_head),
+    because VibeVoice's `model.language_model` slot expects a base model
+    (Qwen2Model, not Qwen2ForCausalLM).
+    """
+    # Strategy 1: direct attribute access
+    candidates = [
+        ("language_model.model", lambda m: getattr(getattr(m, "language_model", None), "model", None)),
+        ("language_model",       lambda m: getattr(m, "language_model", None)),
+        ("text_model",           lambda m: getattr(m, "text_model", None)),
+        ("model",                lambda m: getattr(m, "model", None)),
+    ]
+    for path, getter in candidates:
+        sub = getter(qwen35_model)
+        if sub is not None and hasattr(sub, "embed_tokens") and hasattr(sub, "layers"):
+            return sub, path
+
+    # Strategy 2: recursive search
+    log.warn("Standard attribute paths didn't find text submodule; doing recursive search.")
+    def _search(module: nn.Module, prefix: str = "", depth: int = 0) -> Optional[Tuple[nn.Module, str]]:
+        if depth > 4:
+            return None
+        if hasattr(module, "embed_tokens") and hasattr(module, "layers"):
+            return module, prefix
+        for name, child in module.named_children():
+            result = _search(child, f"{prefix}.{name}" if prefix else name, depth + 1)
+            if result is not None:
+                return result
+        return None
+
+    result = _search(qwen35_model)
+    if result is None:
+        raise RuntimeError(
+            "Could not locate text decoder submodule inside Qwen3.5 model. "
+            "Inspect the model structure manually with print(qwen35_model)."
+        )
+    return result
+
+
+def load_qwen35_text_model(
+    model_path: str = DEFAULT_QWEN35_PATH,
+    dtype: torch.dtype = DEFAULT_DTYPE,
+    device: str = "cpu",
+    download: bool = True,
+) -> Tuple[nn.Module, nn.Module, Dict[str, Any]]:
+    """
+    Load Qwen/Qwen3.5-4B-Base and return the text decoder + embed_tokens.
+
+    Returns:
+        text_model:  Qwen3_5TextModel (base text decoder, no lm_head)
+        embed_tokens: nn.Embedding from the text model (will be tied to lm_head)
+        info:        dict with metadata (hidden_size, num_layers, etc.)
+
+    Strategy:
+        1. Try loading as Qwen3_5ForConditionalGeneration (multimodal) and
+           extract `.language_model.model`.
+        2. If transformers doesn't know Qwen3_5, raise a helpful error
+           telling the user to upgrade transformers (>= 5.3.0.dev0).
+    """
+    from transformers import AutoModelForCausalLM, AutoConfig
+
+    log.info(f"Loading Qwen3.5-4B-Base config from: {model_path}")
+    try:
+        config = AutoConfig.from_pretrained(model_path, trust_remote_code=True)
+    except Exception as e:
+        log.error(f"Failed to load Qwen3.5 config: {e}")
+        log.error(
+            "Qwen3.5 requires a very recent transformers version "
+            "(>= 5.3.0.dev0 or the qwen3.5 branch). "
+            "Install with: pip install -U transformers"
+        )
+        raise
+
+    # Extract text_config from multimodal config
+    if hasattr(config, "text_config"):
+        text_config = config.text_config
+        log.info(
+            f"Qwen3.5 multimodal config detected. "
+            f"Text hidden_size={text_config.hidden_size}, "
+            f"num_layers={text_config.num_hidden_layers}, "
+            f"vocab_size={text_config.vocab_size}"
+        )
+    else:
+        text_config = config
+        log.info(
+            f"Qwen3.5 text-only config. hidden_size={text_config.hidden_size}, "
+            f"num_layers={text_config.num_hidden_layers}"
+        )
+
+    log.info(f"Loading Qwen3.5 weights (dtype={dtype}, device={device})...")
+    kwargs = dict(
+        config=config,
+        trust_remote_code=True,
+        torch_dtype=dtype,
+        low_cpu_mem_usage=True,
+    )
+    if device == "cpu":
+        kwargs["device_map"] = {"": "cpu"}
+    else:
+        kwargs["device_map"] = "auto"
+    if not download:
+        kwargs["local_files_only"] = True
+
+    try:
+        full_model = AutoModelForCausalLM.from_pretrained(model_path, **kwargs)
+    except Exception as e:
+        log.error(f"Failed to load Qwen3.5 full model: {e}")
+        log.error(traceback.format_exc())
+        raise
+
+    # Verify hidden size matches expectation
+    actual_hidden = getattr(text_config, "hidden_size", None)
+    if actual_hidden != NEW_HIDDEN_SIZE:
+        raise RuntimeError(
+            f"Qwen3.5-4B text hidden_size mismatch: expected {NEW_HIDDEN_SIZE}, "
+            f"got {actual_hidden}. The surgery constants in this file need updating."
+        )
+
+    # Extract text submodule
+    text_model, attr_path = _find_text_submodule(full_model)
+    log.info(f"Found text decoder at attribute path: '{attr_path}'")
+
+    # Get embed_tokens
+    if hasattr(text_model, "embed_tokens"):
+        embed_tokens = text_model.embed_tokens
+    else:
+        raise RuntimeError(
+            "Text submodule does not have 'embed_tokens' attribute. "
+            "Cannot proceed with surgery."
+        )
+
+    # Verify embed_tokens shape
+    assert embed_tokens.weight.shape == (
+        NEW_VOCAB_SIZE,
+        NEW_HIDDEN_SIZE,
+    ), f"embed_tokens shape mismatch: {embed_tokens.weight.shape}"
+
+    info = {
+        "hidden_size": text_config.hidden_size,
+        "num_layers": text_config.num_hidden_layers,
+        "vocab_size": text_config.vocab_size,
+        "intermediate_size": getattr(text_config, "intermediate_size", None),
+        "num_attention_heads": getattr(text_config, "num_attention_heads", None),
+        "num_key_value_heads": getattr(text_config, "num_key_value_heads", None),
+        "head_dim": getattr(text_config, "head_dim", None),
+        "text_config_dict": text_config.to_dict() if hasattr(text_config, "to_dict") else {},
+        "loaded_attr_path": attr_path,
+    }
+
+    # IMPORTANT: we return text_model and embed_tokens, but we do NOT free
+    # the full multimodal model yet (the caller may want to inspect it).
+    # The caller should `del full_model` after extracting what they need.
+    text_model.eval()
+
+    log.info(
+        f"Qwen3.5 text model extracted. "
+        f"param count = {sum(p.numel() for p in text_model.parameters()):,}"
+    )
+
+    # Stash the full model on the text_model object so the caller can free it
+    text_model._full_qwen35_multimodal = full_model  # type: ignore[attr-defined]
+
+    return text_model, embed_tokens, info
+
+
+# =========================================================================== #
+#  3.  ZERO-INIT PADDING PRIMITIVES                                            #
+#  These are the building blocks for expanding any layer while preserving     #
+#  old knowledge.                                                             #
+# =========================================================================== #
+
+def _make_new_linear(
+    in_features: int,
+    out_features: int,
+    bias: bool,
+    dtype: torch.dtype,
+    device: str = "cpu",
+) -> nn.Linear:
+    """Create a fresh nn.Linear with the given shape."""
+    layer = nn.Linear(in_features, out_features, bias=bias, device=device, dtype=dtype)
+    return layer
+
+
+def expand_linear_output(
+    linear: nn.Linear,
+    new_out_features: int,
+    dtype: torch.dtype,
+    init_mode: str = "zero",
+    std: float = 0.02,
+) -> nn.Linear:
+    """
+    Expand ONLY the output dimension of a Linear (input dim unchanged).
+
+    Args:
+        linear:           Original nn.Linear (shape [out, in])
+        new_out_features: Target output dimension (must be > current)
+        dtype:            Target dtype
+        init_mode:        'zero'   - new rows = 0  (silent new outputs)
+                          'noise'  - new rows ~ N(0, std)
+                          'tile'   - new rows = copy of last old row
+        std:              Std for 'noise' mode
+    """
+    old_out, old_in = linear.weight.shape
+    if new_out_features <= old_out:
+        log.warn(f"expand_linear_output: new_out ({new_out_features}) <= old_out ({old_out}); skipping.")
+        return linear
+    if new_out_features == old_out:
+        return linear
+
+    has_bias = linear.bias is not None
+    new_layer = _make_new_linear(old_in, new_out_features, has_bias, dtype)
+
+    with torch.no_grad():
+        # Preserve old rows
+        new_layer.weight.data[:old_out, :] = linear.weight.data.to(dtype)
+        # Init new rows
+        n_new = new_out_features - old_out
+        if init_mode == "zero":
+            new_layer.weight.data[old_out:, :] = 0.0
+        elif init_mode == "noise":
+            new_layer.weight.data[old_out:, :] = torch.randn_like(
+                new_layer.weight.data[old_out:, :]
+            ) * std
+        elif init_mode == "tile":
+            # Repeat the last old row n_new times (gives a non-zero starting point)
+            new_layer.weight.data[old_out:, :] = linear.weight.data[-1:, :].to(dtype).repeat(
+                n_new, 1
+            )
+        else:
+            raise ValueError(f"Unknown init_mode: {init_mode}")
+
+        if has_bias:
+            new_layer.bias.data[:old_out] = linear.bias.data.to(dtype)
+            new_layer.bias.data[old_out:] = 0.0
+
+    return new_layer
+
+
+def expand_linear_input(
+    linear: nn.Linear,
+    new_in_features: int,
+    dtype: torch.dtype,
+    init_mode: str = "zero",
+    std: float = 0.02,
+) -> nn.Linear:
+    """
+    Expand ONLY the input dimension of a Linear (output dim unchanged).
+
+    Args:
+        linear:          Original nn.Linear (shape [out, in])
+        new_in_features: Target input dimension (must be > current)
+        dtype:           Target dtype
+        init_mode:       'zero'  - new cols = 0  (ignore new input dims)
+                         'noise' - new cols ~ N(0, std)
+    """
+    old_out, old_in = linear.weight.shape
+    if new_in_features <= old_in:
+        log.warn(f"expand_linear_input: new_in ({new_in_features}) <= old_in ({old_in}); skipping.")
+        return linear
+    if new_in_features == old_in:
+        return linear
+
+    has_bias = linear.bias is not None
+    new_layer = _make_linear_no_init(new_in_features, old_out, has_bias, dtype)
+
+    with torch.no_grad():
+        new_layer.weight.data[:, :old_in] = linear.weight.data.to(dtype)
+        n_new = new_in_features - old_in
+        if init_mode == "zero":
+            new_layer.weight.data[:, old_in:] = 0.0
+        elif init_mode == "noise":
+            new_layer.weight.data[:, old_in:] = torch.randn_like(
+                new_layer.weight.data[:, old_in:]
+            ) * std
+        else:
+            raise ValueError(f"Unknown init_mode: {init_mode}")
+
+        if has_bias:
+            new_layer.bias.data[:] = linear.bias.data.to(dtype)
+
+    return new_layer
+
+
+def _make_linear_no_init(
+    in_features: int,
+    out_features: int,
+    bias: bool,
+    dtype: torch.dtype,
+    device: str = "cpu",
+) -> nn.Linear:
+    """Create a fresh nn.Linear WITHOUT running its default init (we'll fill it)."""
+    layer = nn.Linear(in_features, out_features, bias=bias, device=device, dtype=dtype)
+    # nn.Linear's __init__ already ran with kaiming_uniform — we'll overwrite
+    # everything, so the default init doesn't matter.
+    return layer
+
+
+def expand_linear_both(
+    linear: nn.Linear,
+    new_in_features: int,
+    new_out_features: int,
+    dtype: torch.dtype,
+    init_mode: str = "zero",
+    std: float = 0.02,
+) -> nn.Linear:
+    """
+    Expand BOTH input and output dims of a Linear.
+
+    Strategy (Zero-Init Padding):
+        W_new[:old_out, :old_in]      = W_old          (preserve block)
+        W_new[:old_out, old_in:]      = 0              (ignore new inputs)
+        W_new[old_out:, :]            = 0              (silent new outputs)
+
+    Args:
+        init_mode: 'zero' (default, recommended) or 'noise'.
+                   'noise' will only apply to the bottom-right new block.
+    """
+    old_out, old_in = linear.weight.shape
+    if new_in_features < old_in:
+        raise ValueError(
+            f"new_in_features ({new_in_features}) < old_in ({old_in}) — "
+            f"shrinking is not supported (would lose knowledge)."
+        )
+    if new_out_features < old_out:
+        raise ValueError(
+            f"new_out_features ({new_out_features}) < old_out ({old_out}) — "
+            f"shrinking is not supported."
+        )
+
+    has_bias = linear.bias is not None
+    new_layer = _make_linear_no_init(new_in_features, new_out_features, has_bias, dtype)
+
+    with torch.no_grad():
+        # Fill with zeros first
+        new_layer.weight.data.zero_()
+
+        # Preserve top-left block
+        new_layer.weight.data[:old_out, :old_in] = linear.weight.data.to(dtype)
+
+        # Bottom-right block (new outputs reading new inputs)
+        if init_mode == "noise":
+            new_layer.weight.data[old_out:, old_in:] = (
+                torch.randn_like(new_layer.weight.data[old_out:, old_in:]) * std
+            )
+        # else: stays zero
+
+        if has_bias:
+            new_layer.bias.data.zero_()
+            new_layer.bias.data[:old_out] = linear.bias.data.to(dtype)
+
+    return new_layer
+
+
+def expand_rmsnorm(norm: nn.Module, new_dim: int, dtype: torch.dtype) -> nn.Module:
+    """
+    Expand a normalization layer (RMSNorm or LayerNorm). Old weights are
+    preserved; new weights = 1.0 (identity contribution from new dims).
+
+    Works for:
+      - vibevoice DiffusionHead RMSNorm (has .weight of shape [dim])
+      - transformers LlamaRMSNorm (has .weight of shape [dim])
+      - nn.LayerNorm (has .weight, .bias, .normalized_shape)
+
+    For LayerNorm we also update normalized_shape to match new_dim.
+    """
+    # Case: no affine params (e.g., final_layer.norm_final with elementwise_affine=False)
+    if not hasattr(norm, "weight") or norm.weight is None:
+        # For LayerNorm without affine, also update normalized_shape
+        if hasattr(norm, "normalized_shape"):
+            norm.normalized_shape = (new_dim,)
+        if hasattr(norm, "dim"):
+            norm.dim = new_dim
+        return norm
+
+    old_dim = norm.weight.shape[0]
+    if new_dim <= old_dim:
+        return norm
+
+    # Create new weight (preserve old, fill new with 1.0)
+    new_weight = torch.ones(new_dim, dtype=dtype, device=norm.weight.device)
+    with torch.no_grad():
+        new_weight[:old_dim] = norm.weight.data.to(dtype)
+        # new_weight[old_dim:] already = 1.0 (identity)
+    norm.weight = nn.Parameter(new_weight)
+
+    # Handle bias for LayerNorm
+    if hasattr(norm, "bias") and norm.bias is not None:
+        new_bias = torch.zeros(new_dim, dtype=dtype, device=norm.bias.device)
+        with torch.no_grad():
+            new_bias[:old_dim] = norm.bias.data.to(dtype)
+        norm.bias = nn.Parameter(new_bias)
+
+    # Update shape attributes
+    if hasattr(norm, "normalized_shape"):
+        norm.normalized_shape = (new_dim,)
+    if hasattr(norm, "dim"):
+        norm.dim = new_dim
+
+    return norm
+
+
+# =========================================================================== #
+#  4.  SPEECH CONNECTOR SURGERY                                                #
+# =========================================================================== #
+
+def expand_speech_connector(
+    connector: nn.Module,
+    new_hidden: int,
+    dtype: torch.dtype,
+) -> Tuple[nn.Module, int]:
+    """
+    Expand a SpeechConnector from old_hidden=1536 to new_hidden=2560.
+
+    SpeechConnector structure (from modeling_vibevoice.py):
+        fc1   : Linear(input_dim -> old_hidden)    # input_dim is 64 or 128
+        norm  : LlamaRMSNorm(old_hidden)
+        fc2   : Linear(old_hidden -> old_hidden)
+
+    Surgery:
+        fc1   : Linear(input_dim -> new_hidden)    # input unchanged, output grows
+                                                   # new output rows init ZERO
+        norm  : LlamaRMSNorm(new_hidden)           # new weights = 1.0
+        fc2   : Linear(new_hidden -> new_hidden)   # both grow, ZIP block
+    """
+    old_hidden = connector.fc2.out_features  # reliable way to get old hidden
+    input_dim = connector.fc1.in_features
+
+    if old_hidden == new_hidden:
+        log.info(f"  SpeechConnector already at hidden={new_hidden}, skipping.")
+        return connector, 0
+
+    log.info(
+        f"  Expanding SpeechConnector: input_dim={input_dim}, "
+        f"hidden {old_hidden} -> {new_hidden}"
+    )
+
+    # fc1: input unchanged, output grows. New rows ZERO (silent new outputs).
+    new_fc1 = expand_linear_output(
+        connector.fc1, new_out_features=new_hidden, dtype=dtype, init_mode="zero"
+    )
+
+    # norm: new weights = 1.0
+    new_norm = expand_rmsnorm(connector.norm, new_dim=new_hidden, dtype=dtype)
+
+    # fc2: both grow. ZIP block.
+    new_fc2 = expand_linear_both(
+        connector.fc2,
+        new_in_features=new_hidden,
+        new_out_features=new_hidden,
+        dtype=dtype,
+        init_mode="zero",
+    )
+
+    connector.fc1 = new_fc1
+    connector.norm = new_norm
+    connector.fc2 = new_fc2
+
+    preserved = (
+        input_dim * old_hidden        # fc1 preserved block
+        + old_hidden                  # norm preserved
+        + old_hidden * old_hidden     # fc2 preserved block
+    )
+    return connector, preserved
+
+
+# =========================================================================== #
+#  5.  DIFFUSION HEAD SURGERY                                                  #
+# =========================================================================== #
+
+def expand_diffusion_head(
+    head: nn.Module,
+    new_hidden: int,
+    dtype: torch.dtype,
+) -> Tuple[nn.Module, int]:
+    """
+    Expand the VibeVoiceDiffusionHead from old_hidden=1536 to new_hidden=2560.
+
+    DiffusionHead structure (from modular_vibevoice_diffusion_head.py):
+        noisy_images_proj : Linear(latent=64 -> hidden)
+        cond_proj         : Linear(hidden -> hidden)
+        t_embedder.mlp[0] : Linear(256 -> hidden)         # frequency -> hidden
+        t_embedder.mlp[2] : Linear(hidden -> hidden)
+        layers[i].ffn:
+            gate_proj     : Linear(hidden -> ffn_dim)
+            up_proj       : Linear(hidden -> ffn_dim)
+            down_proj     : Linear(ffn_dim -> hidden)
+        layers[i].norm    : RMSNorm(hidden)
+        layers[i].adaLN_modulation : Linear(hidden -> 3*hidden)   # MUST stay zero!
+        final_layer.norm_final      : RMSNorm(hidden, elementwise_affine=False)
+        final_layer.linear          : Linear(hidden -> latent=64)
+        final_layer.adaLN_modulation: Linear(hidden -> 2*hidden)  # MUST stay zero!
+
+    Surgery strategy per layer:
+        noisy_images_proj : output grows, init ZERO for new rows
+        cond_proj         : both grow, ZIP block (new cols=0, new rows=0)
+        t_embedder.mlp[0] : output grows, init NOISE (this layer was random-init
+                            in original code, so new capacity gets same dist)
+        t_embedder.mlp[2] : both grow, ZIP block
+        ffn.gate_proj     : output grows (ffn_dim grows 4608 -> 7680), init ZERO
+        ffn.up_proj       : output grows, init ZERO
+        ffn.down_proj     : input grows, output stays — new cols ZERO
+        layers[i].norm    : new weights = 1.0
+        layers[i].adaLN   : MUST be ZERO (was zero-init originally).
+                            Re-init the WHOLE layer to zero to preserve behavior.
+        final_layer.norm_final : no affine params (skip)
+        final_layer.linear     : input grows, output stays. Old was zero. Keep zero.
+        final_layer.adaLN      : MUST be ZERO. Re-init whole layer to zero.
+    """
+    old_hidden = head.cond_proj.in_features
+    if old_hidden == new_hidden:
+        log.info(f"  DiffusionHead already at hidden={new_hidden}, skipping.")
+        return head, 0
+
+    new_ffn_dim = int(new_hidden * head.config.head_ffn_ratio)
+    old_ffn_dim = int(old_hidden * head.config.head_ffn_ratio)
+    latent_size = head.config.latent_size
+    freq_emb_size = head.t_embedder.frequency_embedding_size  # 256
+
+    log.info(
+        f"  Expanding DiffusionHead: hidden {old_hidden} -> {new_hidden}, "
+        f"ffn {old_ffn_dim} -> {new_ffn_dim}, latent={latent_size}, freq_emb={freq_emb_size}"
+    )
+
+    preserved = 0
+
+    # 1. noisy_images_proj: Linear(latent -> hidden). Output grows.
+    #    Old preserved block: [old_hidden, latent_size]. New rows: ZERO.
+    head.noisy_images_proj = expand_linear_output(
+        head.noisy_images_proj,
+        new_out_features=new_hidden,
+        dtype=dtype,
+        init_mode="zero",
+    )
+    preserved += old_hidden * latent_size
+
+    # 2. cond_proj: Linear(hidden -> hidden). Both grow, ZIP block.
+    head.cond_proj = expand_linear_both(
+        head.cond_proj,
+        new_in_features=new_hidden,
+        new_out_features=new_hidden,
+        dtype=dtype,
+        init_mode="zero",
+    )
+    preserved += old_hidden * old_hidden
+
+    # 3. t_embedder.mlp[0]: Linear(freq_emb=256 -> hidden). Output grows.
+    #    This layer was random-init (std=0.02) in original code, so new rows
+    #    get fresh random init with the same std.
+    head.t_embedder.mlp[0] = expand_linear_output(
+        head.t_embedder.mlp[0],
+        new_out_features=new_hidden,
+        dtype=dtype,
+        init_mode="noise",
+        std=0.02,
+    )
+    preserved += old_hidden * freq_emb_size
+
+    # 4. t_embedder.mlp[2]: Linear(hidden -> hidden). Both grow, ZIP block.
+    head.t_embedder.mlp[2] = expand_linear_both(
+        head.t_embedder.mlp[2],
+        new_in_features=new_hidden,
+        new_out_features=new_hidden,
+        dtype=dtype,
+        init_mode="zero",
+    )
+    preserved += old_hidden * old_hidden
+
+    # 5. Per-layer surgery
+    for i, layer in enumerate(head.layers):
+        # ffn.gate_proj: Linear(hidden -> ffn_dim). BOTH grow.
+        # Old preserved: [old_ffn_dim, old_hidden]. New rows/cols ZERO.
+        layer.ffn.gate_proj = expand_linear_both(
+            layer.ffn.gate_proj,
+            new_in_features=new_hidden,
+            new_out_features=new_ffn_dim,
+            dtype=dtype,
+            init_mode="zero",
+        )
+        preserved += old_ffn_dim * old_hidden
+
+        # ffn.up_proj: Linear(hidden -> ffn_dim). BOTH grow.
+        layer.ffn.up_proj = expand_linear_both(
+            layer.ffn.up_proj,
+            new_in_features=new_hidden,
+            new_out_features=new_ffn_dim,
+            dtype=dtype,
+            init_mode="zero",
+        )
+        preserved += old_ffn_dim * old_hidden
+
+        # ffn.down_proj: Linear(ffn_dim -> hidden). BOTH grow.
+        # New rows ZERO (silent new hidden outputs), new cols ZERO (ignore new ffn).
+        layer.ffn.down_proj = expand_linear_both(
+            layer.ffn.down_proj,
+            new_in_features=new_ffn_dim,
+            new_out_features=new_hidden,
+            dtype=dtype,
+            init_mode="zero",
+        )
+        preserved += old_hidden * old_ffn_dim
+
+        # ffn.embed_dim / ffn_dim attrs (used in repr / debugging)
+        layer.ffn.embed_dim = new_hidden
+        layer.ffn.ffn_dim = new_ffn_dim
+
+        # layer.norm: RMSNorm. New weights = 1.0.
+        layer.norm = expand_rmsnorm(layer.norm, new_dim=new_hidden, dtype=dtype)
+        preserved += old_hidden
+
+        # layer.adaLN_modulation: Linear(cond_dim -> 3*hidden). BOTH grow.
+        # CRITICAL: this layer was zero-init in original DiffusionHead.initialize_weights().
+        # To preserve identity behavior, the ENTIRE new layer must be ZERO
+        # (not just the new rows/cols). We re-init everything to zero.
+        new_adaln = _make_linear_no_init(
+            new_hidden, 3 * new_hidden, bias=False, dtype=dtype
+        )
+        with torch.no_grad():
+            new_adaln.weight.data.zero_()
+            # Note: we DON'T preserve old weights here because they were zero
+            # anyway, and mixing zero with non-zero would break the identity
+            # behavior. Keeping everything zero is correct.
+        # The Sequential is [SiLU, Linear]. We replace only the Linear (index 1).
+        layer.adaLN_modulation[1] = new_adaln
+
+        # layer.embed_dim / cond_dim / ffn_dim attrs
+        layer.embed_dim = new_hidden
+        layer.cond_dim = new_hidden
+        layer.ffn_dim = new_ffn_dim
+
+    # 6. final_layer surgery
+    fl = head.final_layer
+
+    # final_layer.norm_final: RMSNorm(hidden, elementwise_affine=False) — no weight,
+    # but we still need to update normalized_shape / dim attributes.
+    fl.norm_final = expand_rmsnorm(fl.norm_final, new_dim=new_hidden, dtype=dtype)
+
+    # final_layer.linear: Linear(hidden -> latent). Input grows, output stays.
+    # Old was ZERO-init. Keep new cols ZERO.
+    fl.linear = expand_linear_input(
+        fl.linear,
+        new_in_features=new_hidden,
+        dtype=dtype,
+        init_mode="zero",
+    )
+
+    # final_layer.adaLN_modulation: Linear(cond_dim -> 2*hidden). Both grow.
+    # CRITICAL: was zero-init. Keep entire layer ZERO.
+    new_final_adaln = _make_linear_no_init(
+        new_hidden, 2 * new_hidden, bias=False, dtype=dtype
+    )
+    with torch.no_grad():
+        new_final_adaln.weight.data.zero_()
+    fl.adaLN_modulation[1] = new_final_adaln
+
+    # Update config to reflect new hidden_size
+    head.config.hidden_size = new_hidden
+
+    # Update cond_dim attribute on head
+    head.cond_dim = new_hidden
+
+    return head, preserved
+
+
+# =========================================================================== #
+#  6.  LLM REPLACEMENT                                                         #
+# =========================================================================== #
+
+def replace_llm(
+    vibevoice_model: nn.Module,
+    new_llm: nn.Module,
+    new_embed_tokens: nn.Module,
+) -> int:
+    """
+    Replace `vibevoice_model.model.language_model` with the new Qwen3.5 text
+    decoder, and update `embed_tokens` references.
+
+    Args:
+        vibevoice_model: VibeVoiceForConditionalGeneration instance
+        new_llm:         Qwen3_5TextModel (base, no lm_head)
+        new_embed_tokens: nn.Embedding from the new LLM
+
+    Returns:
+        Number of LLM parameters (for the report).
+    """
+    log.info("  Replacing language_model with Qwen3.5 text decoder...")
+
+    # Free the old LLM
+    old_llm = vibevoice_model.model.language_model
+    old_param_count = sum(p.numel() for p in old_llm.parameters())
+    log.info(f"  Old LLM (Qwen2.5-1.5B) param count: {old_param_count:,}")
+
+    # Assign new LLM
+    vibevoice_model.model.language_model = new_llm
+
+    new_param_count = sum(p.numel() for p in new_llm.parameters())
+    log.info(f"  New LLM (Qwen3.5-4B text) param count: {new_param_count:,}")
+
+    return new_param_count
+
+
+# =========================================================================== #
+#  7.  LM HEAD UPDATE & WEIGHT TYING                                           #
+# =========================================================================== #
+
+def update_lm_head(
+    vibevoice_model: nn.Module,
+    new_hidden: int,
+    new_vocab: int,
+    dtype: torch.dtype,
+) -> int:
+    """
+    Replace `vibevoice_model.lm_head` with a new Linear(new_hidden -> new_vocab)
+    and tie it to the new LLM's embed_tokens.
+
+    Returns the lm_head param count.
+    """
+    log.info(
+        f"  Updating lm_head: Linear({new_hidden} -> {new_vocab}) "
+        f"(tied to new embed_tokens)"
+    )
+
+    # Get the new embed_tokens
+    new_embed = vibevoice_model.model.language_model.embed_tokens
+
+    # Create new lm_head
+    new_lm_head = nn.Linear(new_hidden, new_vocab, bias=False).to(dtype)
+
+    # Tie weights
+    new_lm_head.weight = new_embed.weight
+
+    # Replace
+    vibevoice_model.lm_head = new_lm_head
+
+    # Update vocab_size attribute
+    vibevoice_model.vocab_size = new_vocab
+
+    # Update config
+    vibevoice_model.config.decoder_config.vocab_size = new_vocab
+    vibevoice_model.config.decoder_config.hidden_size = new_hidden
+    if hasattr(vibevoice_model.config, "tie_word_embeddings"):
+        vibevoice_model.config.tie_word_embeddings = True
+
+    # Update _tied_weights_keys if present
+    if hasattr(vibevoice_model, "_tied_weights_keys"):
+        vibevoice_model._tied_weights_keys = ["lm_head.weight"]
+
+    return new_vocab * new_hidden
+
+
+# =========================================================================== #
+#  8.  CONFIG UPDATE                                                           #
+# =========================================================================== #
+
+def update_vibevoice_config(
+    vibevoice_model: nn.Module,
+    new_llm_config: Any,
+) -> None:
+    """
+    Update VibeVoiceConfig to reflect the new LLM.
+
+    The original VibeVoiceConfig only accepts decoder_config.model_type == "qwen2".
+    We monkey-patch the config to accept "qwen3_5_text" by:
+      1. Setting decoder_config = new_llm_config (the Qwen3.5 text config)
+      2. Patching the VibeVoiceConfig class to accept qwen3_5_text
+      3. Updating relevant derived attributes
+    """
+    log.info("  Updating VibeVoice config...")
+
+    # Monkey-patch VibeVoiceConfig to accept qwen3_5_text
+    from vibevoice.modular.configuration_vibevoice import VibeVoiceConfig
+
+    original_init = VibeVoiceConfig.__init__
+
+    if not getattr(VibeVoiceConfig, "_patched_for_qwen35", False):
+        def patched_init(self, acoustic_tokenizer_config=None, semantic_tokenizer_config=None,
+                         decoder_config=None, **kwargs):
+            if decoder_config is not None and isinstance(decoder_config, dict):
+                mt = decoder_config.get("model_type", "")
+                if mt == "qwen3_5_text":
+                    # Use a generic Qwen3.5 text config class if available,
+                    # otherwise just stuff the dict into a placeholder.
+                    try:
+                        from transformers.models.auto import CONFIG_MAPPING
+                        if "qwen3_5_text" in CONFIG_MAPPING:
+                            cfg_cls = CONFIG_MAPPING["qwen3_5_text"]
+                            self.decoder_config = cfg_cls(**decoder_config)
+                        else:
+                            # Fallback: use a generic PretrainedConfig
+                            from transformers import PretrainedConfig
+                            self.decoder_config = PretrainedConfig(**decoder_config)
+                    except Exception:
+                        from transformers import PretrainedConfig
+                        self.decoder_config = PretrainedConfig(**decoder_config)
+                elif mt == "qwen2":
+                    from transformers.models.qwen2.configuration_qwen2 import Qwen2Config
+                    self.decoder_config = Qwen2Config(**decoder_config)
+                else:
+                    raise ValueError(f"Unsupported decoder model type: {mt}")
+            elif decoder_config is not None:
+                self.decoder_config = decoder_config
+            else:
+                # Default to Qwen2 (for backward compat)
+                from transformers.models.qwen2.configuration_qwen2 import Qwen2Config
+                self.decoder_config = Qwen2Config()
+
+            # Continue with the rest of the original init logic (copied)
+            if acoustic_tokenizer_config is None:
+                from vibevoice.modular.configuration_vibevoice import VibeVoiceAcousticTokenizerConfig
+                self.acoustic_tokenizer_config = VibeVoiceAcousticTokenizerConfig()
+            elif isinstance(acoustic_tokenizer_config, dict):
+                from vibevoice.modular.configuration_vibevoice import VibeVoiceAcousticTokenizerConfig
+                acoustic_tokenizer_config["model_type"] = "vibevoice_acoustic_tokenizer"
+                self.acoustic_tokenizer_config = VibeVoiceAcousticTokenizerConfig(**acoustic_tokenizer_config)
+            elif hasattr(acoustic_tokenizer_config, "model_type"):
+                self.acoustic_tokenizer_config = acoustic_tokenizer_config
+
+            if semantic_tokenizer_config is None:
+                from vibevoice.modular.configuration_vibevoice import VibeVoiceSemanticTokenizerConfig
+                self.semantic_tokenizer_config = VibeVoiceSemanticTokenizerConfig()
+            elif isinstance(semantic_tokenizer_config, dict):
+                from vibevoice.modular.configuration_vibevoice import VibeVoiceSemanticTokenizerConfig
+                semantic_tokenizer_config["model_type"] = "vibevoice_semantic_tokenizer"
+                self.semantic_tokenizer_config = VibeVoiceSemanticTokenizerConfig(**semantic_tokenizer_config)
+            elif hasattr(semantic_tokenizer_config, "model_type"):
+                self.semantic_tokenizer_config = semantic_tokenizer_config
+
+            # Diffusion head config
+            diff_cfg = kwargs.pop("diffusion_head_config", None)
+            if diff_cfg is None:
+                from vibevoice.modular.configuration_vibevoice import VibeVoiceDiffusionHeadConfig
+                self.diffusion_head_config = VibeVoiceDiffusionHeadConfig()
+            elif isinstance(diff_cfg, dict):
+                from vibevoice.modular.configuration_vibevoice import VibeVoiceDiffusionHeadConfig
+                diff_cfg["model_type"] = "vibevoice_diffusion_head"
+                self.diffusion_head_config = VibeVoiceDiffusionHeadConfig(**diff_cfg)
+            elif hasattr(diff_cfg, "model_type"):
+                self.diffusion_head_config = diff_cfg
+
+            self.acoustic_vae_dim = getattr(self.acoustic_tokenizer_config, "vae_dim", 64)
+            self.semantic_vae_dim = getattr(self.semantic_tokenizer_config, "vae_dim", 128)
+
+            kwargs["_attn_implementation_autoset"] = False
+            from transformers.configuration_utils import PretrainedConfig
+            PretrainedConfig.__init__(self, **kwargs)
+
+        VibeVoiceConfig.__init__ = patched_init
+        VibeVoiceConfig._patched_for_qwen35 = True
+        log.info("  VibeVoiceConfig patched to accept qwen3_5_text model_type.")
+
+    # Now update the model's config
+    vibevoice_model.config.decoder_config = new_llm_config
+    vibevoice_model.config.diffusion_head_config.hidden_size = NEW_HIDDEN_SIZE
+
+    # Update derived properties
+    if hasattr(vibevoice_model.config, "acoustic_vae_dim"):
+        vibevoice_model.config.acoustic_vae_dim = ACOUSTIC_VAE_DIM
+    if hasattr(vibevoice_model.config, "semantic_vae_dim"):
+        vibevoice_model.config.semantic_vae_dim = SEMANTIC_VAE_DIM
+
+
+# =========================================================================== #
+#  9.  VERIFICATION                                                            #
+# =========================================================================== #
+
+def verify_dimensions(model: nn.Module) -> bool:
+    """Verify all expanded dimensions are correct."""
+    log.section("VERIFICATION: Dimension Check")
+    ok = True
+
+    checks = [
+        ("model.language_model.embed_tokens.weight",
+         getattr(model.model.language_model, "embed_tokens", None),
+         (NEW_VOCAB_SIZE, NEW_HIDDEN_SIZE)),
+        ("model.acoustic_connector.fc1.out_features",
+         getattr(model.model.acoustic_connector, "fc1", None),
+         None),  # just check out_features
+        ("model.acoustic_connector.fc2.weight",
+         getattr(model.model.acoustic_connector, "fc2", None),
+         (NEW_HIDDEN_SIZE, NEW_HIDDEN_SIZE)),
+        ("model.semantic_connector.fc2.weight",
+         getattr(model.model.semantic_connector, "fc2", None),
+         (NEW_HIDDEN_SIZE, NEW_HIDDEN_SIZE)),
+        ("model.prediction_head.cond_proj.weight",
+         getattr(model.model.prediction_head, "cond_proj", None),
+         (NEW_HIDDEN_SIZE, NEW_HIDDEN_SIZE)),
+        ("model.prediction_head.noisy_images_proj.weight",
+         getattr(model.model.prediction_head, "noisy_images_proj", None),
+         (NEW_HIDDEN_SIZE, DIFFUSION_LATENT_SIZE)),
+        ("model.prediction_head.final_layer.linear.weight",
+         getattr(model.model.prediction_head, "final_layer", None),
+         None),
+        ("lm_head.weight",
+         getattr(model, "lm_head", None),
+         (NEW_VOCAB_SIZE, NEW_HIDDEN_SIZE)),
+    ]
+
+    for name, attr, expected_shape in checks:
+        if attr is None:
+            log.warn(f"  {name}: MISSING")
+            ok = False
+            continue
+
+        if hasattr(attr, "weight"):
+            shape = tuple(attr.weight.shape)
+        elif hasattr(attr, "shape"):
+            shape = tuple(attr.shape)
+        elif hasattr(attr, "out_features"):
+            shape = (attr.out_features, attr.in_features)
+        else:
+            shape = "<unknown>"
+
+        if expected_shape is None:
+            log.info(f"  {name}: {shape} (informational)")
+        elif shape == expected_shape:
+            log.info(f"  {name}: {shape}  OK")
+        else:
+            log.error(f"  {name}: {shape}  EXPECTED {expected_shape}  MISMATCH!")
+            ok = False
+
+    return ok
+
+
+def verify_zero_init_behavior(model: nn.Module, dtype: torch.dtype) -> bool:
+    """
+    Verify that the new capacity dims (1536:2560) of every expanded layer
+    contribute ZERO at init time. We do this by:
+      1. Running a tiny forward pass with random inputs
+      2. Checking that the output's new dims are zero (or near-zero)
+    """
+    log.section("VERIFICATION: Zero-Init Behavior")
+
+    # Test 1: acoustic_connector
+    try:
+        x = torch.randn(2, 4, ACOUSTIC_VAE_DIM, dtype=dtype)
+        out = model.model.acoustic_connector(x)
+        new_part = out[..., OLD_HIDDEN_SIZE:]
+        max_new = new_part.abs().max().item()
+        log.info(f"  acoustic_connector new dims max abs: {max_new:.6e}")
+        if max_new > 1e-6:
+            log.warn(f"  acoustic_connector new dims not zero (max={max_new}). "
+                     f"This may indicate the fc1 init is not zero.")
+            # Actually fc1 zero-init means output of fc1 is zero in new dims,
+            # but then norm and fc2 are applied. fc2 has zero rows in new
+            # output dims so output is still zero. But fc1 output is zero in
+            # new dims means RMSNorm divides by sqrt(mean of squares) which
+            # includes the zero new dims... wait, RMSNorm normalizes per-token,
+            # not per-dim. Let me think again.
+            #
+            # RMSNorm operates on the last dim. So for a token with shape [2560],
+            # if the first 1536 are non-zero (from fc1) and the last 1024 are
+            # zero (from fc1 zero-init on new rows), then RMSNorm computes:
+            #   x_rms = sqrt(mean(x^2)) = sqrt(sum(x^2) / 2560)
+            #   y = x / x_rms
+            # The new dims (which were 0) stay 0 after division.
+            # Then y is multiplied by weight (1.0 for new dims).
+            # So new dims of norm output = 0.
+            # Then fc2: input has new dims = 0, weight has new cols = 0 (zero-init).
+            # Output new dims: sum over input of (input * weight) for new out rows.
+            # new out rows are all zero (zero-init), so output new dims = 0.
+            # So the answer should be zero. The warning above shouldn't trigger
+            # unless something is wrong. Let me make the threshold tighter.
+            pass
+        else:
+            log.info(f"  acoustic_connector: new dims are zero (OK)")
+    except Exception as e:
+        log.error(f"  acoustic_connector forward failed: {e}")
+        return False
+
+    # Test 2: semantic_connector
+    try:
+        x = torch.randn(2, 4, SEMANTIC_VAE_DIM, dtype=dtype)
+        out = model.model.semantic_connector(x)
+        new_part = out[..., OLD_HIDDEN_SIZE:]
+        max_new = new_part.abs().max().item()
+        log.info(f"  semantic_connector new dims max abs: {max_new:.6e}")
+        if max_new > 1e-6:
+            log.warn(f"  semantic_connector new dims not zero (max={max_new})")
+    except Exception as e:
+        log.error(f"  semantic_connector forward failed: {e}")
+        return False
+
+    # Test 3: diffusion_head
+    try:
+        noisy = torch.randn(2, 4, DIFFUSION_LATENT_SIZE, dtype=dtype)
+        t = torch.tensor([10, 50], dtype=dtype)
+        cond = torch.randn(2, 4, NEW_HIDDEN_SIZE, dtype=dtype)
+        # Set cond's old dims to zero, new dims to non-zero — verify output is zero
+        cond_zero_old = cond.clone()
+        cond_zero_old[..., :OLD_HIDDEN_SIZE] = 0
+        out = model.model.prediction_head(noisy, t, cond_zero_old)
+        max_out = out.abs().max().item()
+        log.info(f"  diffusion_head output (cond new-dims-only) max abs: {max_out:.6e}")
+        if max_out > 1e-5:
+            log.warn(
+                f"  diffusion_head: new cond dims produced non-zero output ({max_out}). "
+                f"This is unexpected — adaLN modulation should be zero."
+            )
+    except Exception as e:
+        log.error(f"  diffusion_head forward failed: {e}")
+        log.error(traceback.format_exc())
+        return False
+
+    # Test 4: full model forward (input_ids only, no speech)
+    try:
+        log.info("  Running full model forward (input_ids only)...")
+        # Use small batch / short seq to save memory
+        input_ids = torch.randint(0, 100, (1, 8), dtype=torch.long)
+        with torch.no_grad():
+            outputs = model(input_ids=input_ids, return_dict=True)
+        logits = outputs.logits
+        log.info(f"  Full model forward OK. logits shape: {tuple(logits.shape)}")
+        if logits.shape[-1] != NEW_VOCAB_SIZE:
+            log.error(
+                f"  logits vocab size mismatch: {logits.shape[-1]} != {NEW_VOCAB_SIZE}"
+            )
+            return False
+        if logits.shape[-2] != 8:
+            log.error(f"  logits seq len mismatch: {logits.shape[-2]} != 8")
+            return False
+    except Exception as e:
+        log.error(f"  Full model forward failed: {e}")
+        log.error(traceback.format_exc())
+        return False
+
+    return True
+
+
+def count_parameters(model: nn.Module) -> Dict[str, int]:
+    """Count parameters by submodule."""
+    counts = {
+        "total": 0,
+        "llm": 0,
+        "acoustic_connector": 0,
+        "semantic_connector": 0,
+        "prediction_head": 0,
+        "acoustic_tokenizer": 0,
+        "semantic_tokenizer": 0,
+        "lm_head": 0,
+    }
+
+    if hasattr(model, "model"):
+        inner = model.model
+        if hasattr(inner, "language_model"):
+            counts["llm"] = sum(p.numel() for p in inner.language_model.parameters())
+        if hasattr(inner, "acoustic_connector"):
+            counts["acoustic_connector"] = sum(p.numel() for p in inner.acoustic_connector.parameters())
+        if hasattr(inner, "semantic_connector"):
+            counts["semantic_connector"] = sum(p.numel() for p in inner.semantic_connector.parameters())
+        if hasattr(inner, "prediction_head"):
+            counts["prediction_head"] = sum(p.numel() for p in inner.prediction_head.parameters())
+        if hasattr(inner, "acoustic_tokenizer"):
+            counts["acoustic_tokenizer"] = sum(p.numel() for p in inner.acoustic_tokenizer.parameters())
+        if hasattr(inner, "semantic_tokenizer"):
+            counts["semantic_tokenizer"] = sum(p.numel() for p in inner.semantic_tokenizer.parameters())
+
+    if hasattr(model, "lm_head"):
+        counts["lm_head"] = sum(p.numel() for p in model.lm_head.parameters())
+
+    counts["total"] = sum(p.numel() for p in model.parameters())
+    # Subtract tied lm_head from total to avoid double-counting
+    counts["total_effective"] = counts["total"] - counts["lm_head"]
+    return counts
+
+
+# =========================================================================== #
+#  10. SAVE / LOAD                                                             #
+# =========================================================================== #
+
+def save_surgered_model(model: nn.Module, output_dir: str) -> str:
+    """
+    Save the surgered model in HF format.
+
+    Args:
+        model:      The surgered VibeVoiceForConditionalGeneration
+        output_dir: Target directory
+
+    Returns:
+        Path to the saved model directory.
+    """
+    output_dir = os.path.abspath(output_dir)
+    os.makedirs(output_dir, exist_ok=True)
+
+    log.section(f"SAVING SURGERED MODEL -> {output_dir}")
+
+    # Save model weights in safetensors format
+    model.save_pretrained(
+        output_dir,
+        safe_serialization=True,
+        max_shard_size="5GB",  # split into 5GB shards for safety
+    )
+
+    # Save an extra metadata file describing the surgery
+    meta = {
+        "surgery": "VibeVoice-1.5B -> VibeVoice-4B",
+        "original_llm": "Qwen2.5-1.5B (Qwen2)",
+        "new_llm": "Qwen3.5-4B-Base text decoder (Qwen3_5TextModel)",
+        "old_hidden_size": OLD_HIDDEN_SIZE,
+        "new_hidden_size": NEW_HIDDEN_SIZE,
+        "old_vocab_size": OLD_VOCAB_SIZE,
+        "new_vocab_size": NEW_VOCAB_SIZE,
+        "strategy": "Zero-Init Padding (ZIP)",
+        "notes": [
+            "Acoustic/Semantic tokenizers are unchanged.",
+            "Diffusion head expanded from 1536 to 2560 with ZIP.",
+            "Connectors expanded from 1536 to 2560 with ZIP.",
+            "adaLN modulation layers re-zeroed to preserve identity behavior.",
+            "lm_head tied to new Qwen3.5 embed_tokens.",
+            "New capacity dims (1536:2560) contribute ZERO at init time.",
+            "Fine-tuning is REQUIRED to make new capacity useful.",
+        ],
+    }
+    with open(os.path.join(output_dir, "surgery_metadata.json"), "w") as f:
+        json.dump(meta, f, indent=2)
+
+    log.info(f"  Saved metadata to {output_dir}/surgery_metadata.json")
+    log.info(f"  Model saved to {output_dir}")
+    return output_dir
+
+
+# =========================================================================== #
+#  11. FULL SURGERY ORCHESTRATION                                              #
+# =========================================================================== #
+
+def perform_full_surgery(cfg: SurgeryConfig) -> SurgeryReport:
+    """
+    Run the complete surgery procedure:
+      1. Load VibeVoice-1.5B
+      2. Load Qwen3.5-4B-Base, extract text decoder
+      3. Replace LLM
+      4. Expand acoustic connector (ZIP)
+      5. Expand semantic connector (ZIP)
+      6. Expand diffusion head (ZIP)
+      7. Update lm_head + tie weights
+      8. Update config
+      9. Verify dimensions + zero-init behavior
+      10. Save to disk
+
+    Returns a SurgeryReport.
+    """
+    log.section("VIBEVOICE 1.5B -> 4B MODEL SURGERY")
+    log.info(f"VibeVoice path : {cfg.vibevoice_path}")
+    log.info(f"Qwen3.5 path   : {cfg.qwen35_path}")
+    log.info(f"Output dir     : {cfg.output_dir}")
+    log.info(f"Dtype          : {cfg.dtype}")
+
+    torch.manual_seed(cfg.seed)
+
+    report = SurgeryReport()
+
+    try:
+        # ----- Step 1: Load VibeVoice-1.5B -----
+        log.section("STEP 1/9: Load original VibeVoice-1.5B")
+        vv_model = load_vibevoice_original(
+            model_path=cfg.vibevoice_path,
+            repo_path=cfg.vibevoice_repo_path,
+            dtype=cfg.dtype,
+            device=cfg.load_device,
+            download=cfg.download_weights,
+        )
+        report.original_param_count = sum(p.numel() for p in vv_model.parameters())
+
+        # ----- Step 2: Load Qwen3.5-4B-Base and extract text decoder -----
+        log.section("STEP 2/9: Load Qwen3.5-4B-Base & extract text decoder")
+        new_llm, new_embed, llm_info = load_qwen35_text_model(
+            model_path=cfg.qwen35_path,
+            dtype=cfg.dtype,
+            device=cfg.load_device,
+            download=cfg.download_weights,
+        )
+        report.llm_param_count = sum(p.numel() for p in new_llm.parameters())
+
+        # ----- Step 3: Replace LLM -----
+        log.section("STEP 3/9: Replace language_model")
+        replace_llm(vv_model, new_llm, new_embed)
+
+        # ----- Step 4: Expand acoustic connector -----
+        log.section("STEP 4/9: Expand acoustic connector (ZIP)")
+        _, p_ac = expand_speech_connector(
+            vv_model.model.acoustic_connector, NEW_HIDDEN_SIZE, cfg.dtype
+        )
+        report.preserved_param_count += p_ac
+
+        # ----- Step 5: Expand semantic connector -----
+        log.section("STEP 5/9: Expand semantic connector (ZIP)")
+        _, p_sc = expand_speech_connector(
+            vv_model.model.semantic_connector, NEW_HIDDEN_SIZE, cfg.dtype
+        )
+        report.preserved_param_count += p_sc
+
+        # ----- Step 6: Expand diffusion head -----
+        log.section("STEP 6/9: Expand diffusion head (ZIP)")
+        _, p_dh = expand_diffusion_head(
+            vv_model.model.prediction_head, NEW_HIDDEN_SIZE, cfg.dtype
+        )
+        report.preserved_param_count += p_dh
+
+        # ----- Step 7: Update lm_head + tie weights -----
+        log.section("STEP 7/9: Update lm_head & tie weights")
+        lm_head_params = update_lm_head(
+            vv_model, NEW_HIDDEN_SIZE, NEW_VOCAB_SIZE, cfg.dtype
+        )
+
+        # ----- Step 8: Update config -----
+        log.section("STEP 8/9: Update VibeVoice config")
+        # Get the Qwen3.5 text config from llm_info
+        text_config_dict = llm_info.get("text_config_dict", {})
+        # Build a PretrainedConfig from it (avoid coupling to Qwen3.5 class)
+        from transformers import PretrainedConfig
+        new_text_config = PretrainedConfig(**text_config_dict)
+        new_text_config.model_type = "qwen3_5_text"
+        update_vibevoice_config(vv_model, new_text_config)
+
+        # ----- Step 9: Verify & save -----
+        log.section("STEP 9/9: Verify & save")
+
+        # Verify dimensions
+        dim_ok = verify_dimensions(vv_model)
+        if not dim_ok:
+            report.warnings.append("Dimension verification found issues (see log).")
+
+        # Verify zero-init behavior
+        if cfg.verify_forward:
+            zip_ok = verify_zero_init_behavior(vv_model, cfg.dtype)
+            if not zip_ok:
+                report.warnings.append("Zero-init behavior verification found issues.")
+
+        # Count parameters
+        counts = count_parameters(vv_model)
+        report.new_param_count = counts["total"]
+        report.diffusion_head_param_count = counts["prediction_head"]
+        report.connector_param_count = (
+            counts["acoustic_connector"] + counts["semantic_connector"]
+        )
+        report.new_param_count_only = (
+            report.new_param_count - report.preserved_param_count
+        )
+
+        # Free the original Qwen3.5 multimodal model (vision parts etc.)
+        if hasattr(new_llm, "_full_qwen35_multimodal"):
+            log.info("  Freeing original Qwen3.5 multimodal model (vision + mtp)...")
+            del new_llm._full_qwen35_multimodal
+            import gc
+            gc.collect()
+
+        # Save
+        out_path = save_surgered_model(vv_model, cfg.output_dir)
+        report.output_path = out_path
+        report.success = True
+
+    except Exception as e:
+        log.error(f"SURGERY FAILED: {e}")
+        log.error(traceback.format_exc())
+        report.errors.append(str(e))
+        report.success = False
+
+    return report
+
+
+# =========================================================================== #
+#  12. MOCK TEST MODE                                                          #
+#  Used by the test notebook cell to verify surgery logic without            #
+#  downloading multi-GB weights.                                              #
+# =========================================================================== #
+
+class MockSpeechConnector(nn.Module):
+    """Mock of SpeechConnector for testing."""
+    def __init__(self, input_dim: int, hidden_dim: int):
+        super().__init__()
+        self.fc1 = nn.Linear(input_dim, hidden_dim)
+        try:
+            from transformers.models.llama.modeling_llama import LlamaRMSNorm
+            self.norm = LlamaRMSNorm(hidden_dim, eps=1e-6)
+        except ImportError:
+            self.norm = nn.LayerNorm(hidden_dim)
+        self.fc2 = nn.Linear(hidden_dim, hidden_dim)
+
+    def forward(self, x):
+        x = self.fc1(x)
+        x = self.norm(x)
+        x = self.fc2(x)
+        return x
+
+
+class MockDiffusionHead(nn.Module):
+    """Mock of VibeVoiceDiffusionHead for testing.
+
+    Re-implements the structure of the real DiffusionHead but without
+    importing transformers (so we can test on a machine without transformers).
+    """
+    def __init__(self, hidden_size: int, latent_size: int, head_layers: int = 4,
+                 head_ffn_ratio: float = 3.0):
+        super().__init__()
+
+        # Use a simple object to hold config attrs
+        class _Cfg:
+            pass
+        self.config = _Cfg()
+        self.config.hidden_size = hidden_size
+        self.config.latent_size = latent_size
+        self.config.head_layers = head_layers
+        self.config.head_ffn_ratio = head_ffn_ratio
+        self.config.rms_norm_eps = 1e-5
+
+        self.cond_dim = hidden_size
+
+        # noisy_images_proj: Linear(latent -> hidden)
+        self.noisy_images_proj = nn.Linear(latent_size, hidden_size, bias=False)
+        # cond_proj: Linear(hidden -> hidden)
+        self.cond_proj = nn.Linear(hidden_size, hidden_size, bias=False)
+        # t_embedder: simple version (Linear(freq -> hidden), Linear(hidden -> hidden))
+        freq_emb = 256
+        self.t_embedder = nn.Module()
+        self.t_embedder.frequency_embedding_size = freq_emb
+        self.t_embedder.mlp = nn.Sequential(
+            nn.Linear(freq_emb, hidden_size, bias=False),
+            nn.SiLU(),
+            nn.Linear(hidden_size, hidden_size, bias=False),
+        )
+
+        # Layers
+        ffn_dim = int(hidden_size * head_ffn_ratio)
+        self.layers = nn.ModuleList()
+        for _ in range(head_layers):
+            layer = nn.Module()
+            layer.embed_dim = hidden_size
+            layer.cond_dim = hidden_size
+            layer.ffn_dim = ffn_dim
+
+            # ffn
+            layer.ffn = nn.Module()
+            layer.ffn.embed_dim = hidden_size
+            layer.ffn.ffn_dim = ffn_dim
+            layer.ffn.gate_proj = nn.Linear(hidden_size, ffn_dim, bias=False)
+            layer.ffn.up_proj = nn.Linear(hidden_size, ffn_dim, bias=False)
+            layer.ffn.down_proj = nn.Linear(ffn_dim, hidden_size, bias=False)
+
+            # norm
+            layer.norm = nn.LayerNorm(hidden_size)
+
+            # adaLN modulation (Sequential: SiLU, Linear)
+            layer.adaLN_modulation = nn.Sequential(
+                nn.SiLU(),
+                nn.Linear(hidden_size, 3 * hidden_size, bias=False),
+            )
+
+            self.layers.append(layer)
+
+        # final layer
+        self.final_layer = nn.Module()
+        # norm_final: no affine
+        self.final_layer.norm_final = nn.LayerNorm(hidden_size, elementwise_affine=False)
+        self.final_layer.linear = nn.Linear(hidden_size, latent_size, bias=False)
+        self.final_layer.adaLN_modulation = nn.Sequential(
+            nn.SiLU(),
+            nn.Linear(hidden_size, 2 * hidden_size, bias=False),
+        )
+
+        # Zero-init adaLN and final_layer.linear (matching real DiffusionHead)
+        for layer in self.layers:
+            nn.init.constant_(layer.adaLN_modulation[1].weight, 0)
+        nn.init.constant_(self.final_layer.adaLN_modulation[1].weight, 0)
+        nn.init.constant_(self.final_layer.linear.weight, 0)
+
+    def forward(self, noisy, t, cond):
+        x = self.noisy_images_proj(noisy)
+        # t_embedder forward
+        half = self.t_embedder.frequency_embedding_size // 2
+        freqs = torch.exp(-math.log(10000) * torch.arange(0, half, dtype=torch.float32) / half)
+        args = t[:, None].float() * freqs[None]
+        t_freq = torch.cat([torch.cos(args), torch.sin(args)], dim=-1)
+        if t_freq.shape[-1] < self.t_embedder.frequency_embedding_size:
+            t_freq = torch.cat([t_freq, torch.zeros_like(t_freq[:, :1])], dim=-1)
+        t_emb = self.t_embedder.mlp(t_freq.to(noisy.dtype))
+
+        cond = self.cond_proj(cond)
+        c = cond + t_emb
+
+        for layer in self.layers:
+            shift, scale, gate = layer.adaLN_modulation(c).chunk(3, dim=-1)
+            # ffn
+            g = layer.ffn.gate_proj(x)
+            u = layer.ffn.up_proj(x)
+            g = F.silu(g)
+            ffn_out = layer.ffn.down_proj(g * u)
+            # norm + modulate
+            x_norm = layer.norm(x)
+            x_mod = x_norm * (1 + scale) + shift
+            x = x + gate * ffn_out
+
+        # final
+        shift, scale = self.final_layer.adaLN_modulation(c).chunk(2, dim=-1)
+        x = self.final_layer.norm_final(x)
+        x = x * (1 + scale) + shift
+        x = self.final_layer.linear(x)
+        return x
+
+
+def run_mock_test() -> bool:
+    """
+    Run a self-contained test of the surgery primitives using small mock
+    modules. This verifies the ZIP logic without downloading any weights.
+
+    Returns True if all tests pass.
+    """
+    log.section("MOCK TEST: Verify ZIP surgery logic with small modules")
+
+    torch.manual_seed(42)
+
+    # Use small dims for speed: old_hidden=16, new_hidden=32, latent=8
+    OLD_H = 16
+    NEW_H = 32
+    LATENT = 8
+    DTYPE = torch.float32
+
+    # ---- Test 1: expand_linear_output ----
+    log.info("Test 1: expand_linear_output (zero init)")
+    lin = nn.Linear(8, OLD_H, bias=False)
+    old_out = lin(torch.randn(1, 8))
+    new_lin = expand_linear_output(lin, NEW_H, DTYPE, init_mode="zero")
+    assert new_lin.weight.shape == (NEW_H, 8), f"shape mismatch: {new_lin.weight.shape}"
+    new_out = new_lin(torch.randn(1, 8))
+    # Old dims of new output should match old output (with new random input they won't,
+    # but we can check that the WEIGHTS are preserved)
+    assert torch.allclose(new_lin.weight.data[:OLD_H], lin.weight.data), \
+        "Old rows not preserved in expand_linear_output"
+    assert new_lin.weight.data[OLD_H:].abs().max() == 0, \
+        "New rows not zero in expand_linear_output"
+    log.info("  PASS")
+
+    # ---- Test 2: expand_linear_input ----
+    log.info("Test 2: expand_linear_input (zero init)")
+    lin = nn.Linear(OLD_H, 8, bias=False)
+    new_lin = expand_linear_input(lin, NEW_H, DTYPE, init_mode="zero")
+    assert new_lin.weight.shape == (8, NEW_H)
+    assert torch.allclose(new_lin.weight.data[:, :OLD_H], lin.weight.data), \
+        "Old cols not preserved"
+    assert new_lin.weight.data[:, OLD_H:].abs().max() == 0, \
+        "New cols not zero"
+    log.info("  PASS")
+
+    # ---- Test 3: expand_linear_both ----
+    log.info("Test 3: expand_linear_both (ZIP block)")
+    lin = nn.Linear(OLD_H, OLD_H, bias=False)
+    new_lin = expand_linear_both(lin, NEW_H, NEW_H, DTYPE, init_mode="zero")
+    assert new_lin.weight.shape == (NEW_H, NEW_H)
+    assert torch.allclose(new_lin.weight.data[:OLD_H, :OLD_H], lin.weight.data), \
+        "Top-left block not preserved"
+    assert new_lin.weight.data[:OLD_H, OLD_H:].abs().max() == 0, \
+        "Top-right block not zero"
+    assert new_lin.weight.data[OLD_H:, :OLD_H].abs().max() == 0, \
+        "Bottom-left block not zero"
+    assert new_lin.weight.data[OLD_H:, OLD_H:].abs().max() == 0, \
+        "Bottom-right block not zero"
+    log.info("  PASS")
+
+    # ---- Test 4: SpeechConnector surgery preserves zero behavior ----
+    log.info("Test 4: SpeechConnector ZIP behavior")
+    conn = MockSpeechConnector(input_dim=8, hidden_dim=OLD_H)
+    # Initialize fc1 with non-zero weights so we can verify preservation
+    nn.init.normal_(conn.fc1.weight, std=0.1)
+    nn.init.normal_(conn.fc2.weight, std=0.1)
+    if hasattr(conn.norm, 'weight'):
+        nn.init.ones_(conn.norm.weight)
+
+    # Save original output for old dims
+    x = torch.randn(2, 4, 8)
+    with torch.no_grad():
+        old_out = conn(x)
+    old_out_old_dims = old_out[..., :OLD_H].clone()
+
+    # Surgically expand
+    conn, _ = expand_speech_connector(conn, NEW_H, DTYPE)
+
+    # Verify new dims of output are zero (since fc1 new rows are zero, fc2 new rows are zero)
+    with torch.no_grad():
+        new_out = conn(x)
+    new_part = new_out[..., OLD_H:]
+    max_new = new_part.abs().max().item()
+    log.info(f"  New output dims max abs: {max_new:.6e}")
+    assert max_new < 1e-6, f"New output dims not zero: {max_new}"
+
+    # Verify old dims are preserved (the OLD LLM dims path through unchanged)
+    # Note: the old dims output will NOT exactly match the old output because
+    # the RMSNorm now divides by a different factor (since the new dims are zero,
+    # the sum of squares is the same, but divided by NEW_H instead of OLD_H).
+    # So old_out_old_dims ≠ new_out[..., :OLD_H]. We can check the SHAPE only.
+    assert new_out.shape == (2, 4, NEW_H), f"Output shape wrong: {new_out.shape}"
+    log.info("  PASS")
+
+    # ---- Test 5: DiffusionHead surgery preserves zero behavior ----
+    log.info("Test 5: DiffusionHead ZIP behavior")
+    head = MockDiffusionHead(hidden_size=OLD_H, latent_size=LATENT, head_layers=2)
+
+    # Surgery
+    head, _ = expand_diffusion_head(head, NEW_H, DTYPE)
+
+    # Verify dimensions
+    assert head.noisy_images_proj.weight.shape == (NEW_H, LATENT)
+    assert head.cond_proj.weight.shape == (NEW_H, NEW_H)
+    assert head.t_embedder.mlp[0].weight.shape == (NEW_H, 256)
+    assert head.t_embedder.mlp[2].weight.shape == (NEW_H, NEW_H)
+    for layer in head.layers:
+        assert layer.ffn.gate_proj.weight.shape == (NEW_H * 3, NEW_H), \
+            f"gate_proj shape: {layer.ffn.gate_proj.weight.shape}"
+        assert layer.ffn.up_proj.weight.shape == (NEW_H * 3, NEW_H)
+        assert layer.ffn.down_proj.weight.shape == (NEW_H, NEW_H * 3)
+        assert layer.adaLN_modulation[1].weight.shape == (3 * NEW_H, NEW_H)
+        # adaLN must be ZERO
+        assert layer.adaLN_modulation[1].weight.abs().max() == 0, \
+            "adaLN modulation not zero (would break identity behavior)"
+    assert head.final_layer.linear.weight.shape == (LATENT, NEW_H)
+    assert head.final_layer.adaLN_modulation[1].weight.shape == (2 * NEW_H, NEW_H)
+    assert head.final_layer.adaLN_modulation[1].weight.abs().max() == 0, \
+        "final_layer adaLN not zero"
+
+    # Forward test: with cond that has zero old dims and non-zero new dims,
+    # the output should be zero (since adaLN modulation is zero).
+    # NOTE: real VibeVoice DiffusionHead uses 2D inputs [N, dim], not 3D.
+    noisy = torch.randn(4, LATENT)
+    t = torch.tensor([10.0, 50.0, 20.0, 60.0])
+    cond = torch.randn(4, NEW_H)
+    cond[..., :OLD_H] = 0  # zero out old dims
+    with torch.no_grad():
+        out = head(noisy, t, cond)
+    max_out = out.abs().max().item()
+    log.info(f"  DiffusionHead output max abs (cond new-dims-only): {max_out:.6e}")
+    assert max_out < 1e-5, f"DiffusionHead output not zero: {max_out}"
+
+    log.info("  PASS")
+
+    log.section("ALL MOCK TESTS PASSED")
+    return True
+
+
+# =========================================================================== #
+#  13. INSPECTION HELPERS                                                      #
+# =========================================================================== #
+
+def inspect_model(model: nn.Module, name: str = "model", max_params: int = 25) -> None:
+    """Print model structure: top-level modules + their parameter shapes."""
+    log.section(f"INSPECT: {name}")
+    total = sum(p.numel() for p in model.parameters())
+    log.info(f"Total parameters: {total:,}")
+    log.info(f"Top-level modules:")
+
+    for n, m in model.named_children():
+        n_params = sum(p.numel() for p in m.parameters())
+        log.info(f"  {n}: {type(m).__name__}  ({n_params:,} params)")
+
+    log.info(f"\nFirst {max_params} parameters:")
+    for i, (n, p) in enumerate(model.named_parameters()):
+        if i >= max_params:
+            log.info(f"  ... ({sum(1 for _ in model.named_parameters()) - i} more)")
+            break
+        log.info(f"  {n}: {tuple(p.shape)}  dtype={p.dtype}")
+
+
+def inspect_qwen35_text_submodule(model_path: str = DEFAULT_QWEN35_PATH) -> None:
+    """Load Qwen3.5-4B-Base and print the structure of the text submodule.
+    Useful for debugging if the surgery can't find the text submodule.
+    """
+    log.section(f"INSPECT QWEN3.5 TEXT SUBMODULE: {model_path}")
+    text_model, embed, info = load_qwen35_text_model(model_path, dtype=DEFAULT_DTYPE, download=True)
+    inspect_model(text_model, name="Qwen3.5 text decoder")
+    log.info(f"\nEmbed tokens shape: {embed.weight.shape}")
+    log.info(f"Text config: hidden={info['hidden_size']}, layers={info['num_layers']}, "
+             f"vocab={info['vocab_size']}")
+
+
+# =========================================================================== #
+#  14. ENTRY POINT (CLI)                                                       #
+# =========================================================================== #
+
+def _parse_args():
+    import argparse
+    p = argparse.ArgumentParser(description="VibeVoice 1.5B -> 4B surgery")
+    p.add_argument("--vibevoice-path", default=DEFAULT_VIBEVOICE_PATH)
+    p.add_argument("--qwen35-path", default=DEFAULT_QWEN35_PATH)
+    p.add_argument("--output-dir", default="/home/z/my-project/download/vibevoice-4b-surgered")
+    p.add_argument("--vibevoice-repo-path", default="/home/z/my-project/repos/VibeVoice")
+    p.add_argument("--dtype", default="bfloat16", choices=["bfloat16", "float16", "float32"])
+    p.add_argument("--device", default="cpu", choices=["cpu", "cuda"])
+    p.add_argument("--no-download", action="store_true", help="Use local files only")
+    p.add_argument("--no-verify", action="store_true", help="Skip forward-pass verification")
+    p.add_argument("--mock-test", action="store_true", help="Run mock test only and exit")
+    p.add_argument("--inspect-qwen35", action="store_true",
+                   help="Load Qwen3.5, print text submodule structure, exit")
+    return p.parse_args()
+
+
+def main():
+    args = _parse_args()
+
+    if args.mock_test:
+        ok = run_mock_test()
+        sys.exit(0 if ok else 1)
+
+    if args.inspect_qwen35:
+        inspect_qwen35_text_submodule(args.qwen35_path)
+        sys.exit(0)
+
+    dtype = getattr(torch, args.dtype)
+    cfg = SurgeryConfig(
+        vibevoice_path=args.vibevoice_path,
+        qwen35_path=args.qwen35_path,
+        output_dir=args.output_dir,
+        vibevoice_repo_path=args.vibevoice_repo_path,
+        dtype=dtype,
+        load_device=args.device,
+        download_weights=not args.no_download,
+        verify_forward=not args.no_verify,
+    )
+
+    report = perform_full_surgery(cfg)
+    print("\n" + report.summary())
+
+    sys.exit(0 if report.success else 1)
+
+
+if __name__ == "__main__":
+    main()