""" VibeVoice LLM Surgery Module ============================ Replace VibeVoice's Qwen2.5-1.5B decoder with Qwen3.5-4B-Base, while preserving prior knowledge in the diffusion head and speech connectors via width expansion. Architecture changes (from -> to): - LLM Decoder: Qwen2.5-1.5B -> Qwen3.5-4B-Base (text part) * hidden_size: 1536 -> 2560 * num_hidden_layers: 28 -> 32 * vocab_size: 151936 -> 248320 * attention: pure GQA -> hybrid Gated-DeltaNet + GQA (3:1) - Acoustic connector output dim: 1536 -> 2560 (zero-pad expansion) - Semantic connector output dim: 1536 -> 2560 (zero-pad expansion) - Diffusion head hidden_size: 1536 -> 2560 (zero-pad expansion, cond_proj re-initialized) - Acoustic/Semantic Tokenizers: UNCHANGED (independent of LLM dim) Knowledge preservation strategy ------------------------------- For each Linear layer expanded from (in_old, out_old) to (in_new, out_new): - top-left (in_old, out_old) block: copy old weights verbatim - new output rows (out_old:out_new): zero-initialised -> these dims contribute nothing to downstream computation - new input columns (in_old:in_new): zero-initialised -> old behaviour on the preserved dims is identical For RMSNorm: - first dim_old entries: copy old weight - new entries: filled with 1.0 (identity contribution) The cond_proj layer of the diffusion head is RE-INITIALISED because its input space (the LLM hidden states) is fundamentally different between Qwen2.5 and Qwen3.5 (hybrid linear/full attention). Width-expanding it would not preserve meaningful knowledge because the *meaning* of each hidden dimension has changed. The other diffusion-head layers operate on the head's own hidden space, which is preserved by the width expansion. After surgery the model is functional but its outputs will be degraded until a short fine-tuning phase adapts the preserved weights to the new LLM's representation space. Hardware target: 2x T4 (16 GB VRAM each) + 30 GB system RAM (Kaggle). The surgery itself runs in CPU RAM (no GPU needed for tensor manipulations). Verification / generation runs on a single T4 in bfloat16. """ from __future__ import annotations import gc import json import math import os import shutil import sys import warnings from dataclasses import dataclass 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 # ============================================================================ # Section 1: Configuration constants & dataclasses # ============================================================================ # --- Old LLM (Qwen2.5-1.5B) specs (from configs/qwen2.5_1.5b_64k.json) --- OLD_LLM_HIDDEN_SIZE = 1536 OLD_LLM_LAYERS = 28 OLD_LLM_VOCAB = 151936 OLD_LLM_INTERMEDIATE = 8960 OLD_LLM_HEADS = 12 OLD_LLM_KV_HEADS = 2 # --- New LLM (Qwen3.5-4B-Base text part) specs (from HF config.json) --- NEW_LLM_HIDDEN_SIZE = 2560 NEW_LLM_LAYERS = 32 NEW_LLM_VOCAB = 248320 NEW_LLM_INTERMEDIATE = 9216 NEW_LLM_HEADS = 16 NEW_LLM_KV_HEADS = 4 NEW_LLM_REPO = "Qwen/Qwen3.5-4B-Base" # --- Diffusion head defaults (from configs/qwen2.5_1.5b_64k.json) --- DIFFUSION_HEAD_LAYERS = 4 DIFFUSION_HEAD_FFN_RATIO = 3.0 DIFFUSION_HEAD_LATENT_SIZE = 64 DIFFUSION_HEAD_RMS_EPS = 1e-5 # --- Acoustic / Semantic tokenizer VAE dims (UNCHANGED through surgery) --- ACOUSTIC_VAE_DIM = 64 SEMANTIC_VAE_DIM = 128 @dataclass class SurgeryReport: """Tracks everything that happened during surgery for logging/auditing.""" old_llm_hidden: int new_llm_hidden: int old_vocab: int new_vocab: int expanded_modules: List[str] reinitialized_modules: List[str] preserved_modules: List[str] total_params_before: int total_params_after: int output_dir: str def summary(self) -> str: delta = self.total_params_after - self.total_params_before pct = 100.0 * delta / max(self.total_params_before, 1) lines = [ "=" * 70, "VibeVoice Surgery Report", "=" * 70, f" LLM hidden size: {self.old_llm_hidden} -> {self.new_llm_hidden}", f" Vocab size: {self.old_vocab} -> {self.new_vocab}", f" Params before: {self.total_params_before:,}", f" Params after: {self.total_params_after:,}", f" Delta: {delta:+,} ({pct:+.2f}%)", "", f" Expanded (zero-pad): {len(self.expanded_modules)} modules", f" Re-initialised: {len(self.reinitialized_modules)} modules", f" Preserved unchanged: {len(self.preserved_modules)} modules", "", f" Output directory: {self.output_dir}", "=" * 70, ] return "\n".join(lines) # ============================================================================ # Section 2: Path setup & VibeVoice module loader # ============================================================================ def setup_vibevoice_imports(vibevoice_repo_dir: Union[str, Path]) -> None: """ Add the VibeVoice repo root to sys.path and import its modelling modules so that AutoModel picks up the VibeVoice registrations. `vibevoice_repo_dir` can be EITHER: - The directory that *contains* the `vibevoice/` Python package. Example: `/kaggle/working/VibeVoice/` (where `vibevoice/` lives inside) - The `vibevoice/` package directory itself. Example: `/kaggle/working/VibeVoice/vibevoice/` - The `src/` directory of a finetuning fork (containing `vibevoice/`). - The repo root of a finetuning fork (containing `src/vibevoice/`). The function auto-detects which case it is by checking for the existence of the `modular/` subdirectory (which is the key marker of the vibevoice package) containing `configuration_vibevoice.py`. IMPORTANT: The official Microsoft VibeVoice `__init__.py` imports streaming classes (`VibeVoiceStreamingForConditionalGenerationInference`, etc.) that may not exist in all forks and that trigger `AutoModel.register()` calls which collide with transformers 5.x's builtin VibeVoice classes. To avoid this, we ALWAYS replace `vibevoice/__init__.py` with a minimal stub before importing the package. The original file is backed up as `__init__.py.original` so it can be restored later if needed. """ p = Path(vibevoice_repo_dir).resolve() def _looks_like_vibevoice_pkg(d: Path) -> bool: """A directory looks like the vibevoice package if it has a `modular/` subdirectory containing `configuration_vibevoice.py`.""" return (d / "modular" / "configuration_vibevoice.py").exists() def _find_vibevoice_pkg(start: Path) -> Path: """Walk up to 3 levels looking for the vibevoice package directory.""" candidates = [ start, # path IS the package start / "vibevoice", # path contains vibevoice/ start / "src" / "vibevoice", # finetuning fork: path/src/vibevoice start.parent, # parent might be the package start.parent / "vibevoice", start.parent / "src" / "vibevoice", start.parent.parent, start.parent.parent / "vibevoice", start.parent.parent / "src" / "vibevoice", ] for c in candidates: if _looks_like_vibevoice_pkg(c): return c return None # Auto-detect: find the vibevoice package directory vv_pkg_dir = _find_vibevoice_pkg(p) if vv_pkg_dir is None: raise ImportError( f"Cannot find the 'vibevoice' package near {vibevoice_repo_dir}.\n" f"Looked for a directory containing 'modular/configuration_vibevoice.py' " f"in the following candidates:\n" f" - {p}\n" f" - {p}/vibevoice/\n" f" - {p}/src/vibevoice/\n" f" - {p.parent}\n" f" - {p.parent}/vibevoice/\n" f" - {p.parent}/src/vibevoice/\n" f" - {p.parent.parent}\n" f" - {p.parent.parent}/vibevoice/\n" f" - {p.parent.parent}/src/vibevoice/\n" f"\nPlease pass the path to the directory that contains the " f"'vibevoice/' folder (the repo root), OR the path to the " f"'vibevoice/' folder itself." ) repo_root = vv_pkg_dir.parent if str(repo_root) not in sys.path: sys.path.insert(0, str(repo_root)) # === IMPORTANT: Replace vibevoice/__init__.py with a minimal stub === # The official Microsoft VibeVoice __init__.py imports streaming classes # that: # (a) may not exist in all forks (e.g. the finetuning fork doesn't have them) # (b) trigger AutoModel.register() calls that collide with transformers 5.x's # builtin VibeVoice classes, raising: # ValueError: 'VibeVoiceAcousticTokenizerConfig' is already used by a # Transformers model. # We avoid both issues by replacing __init__.py with an empty stub BEFORE # importing the package. The original file is backed up. init_file = vv_pkg_dir / "__init__.py" backup_file = vv_pkg_dir / "__init__.py.original" stub_content = ( "# Auto-generated stub by surgery.py\n" "# The original VibeVoice __init__.py imports streaming classes that\n" "# (a) may not exist in all forks and (b) trigger AutoModel.register()\n" "# calls that collide with transformers 5.x's builtin VibeVoice classes.\n" "# Surgery.py imports the needed modules explicitly, so this stub can\n" "# be empty. The original file is backed up as __init__.py.original.\n" ) if init_file.exists(): original_content = init_file.read_text() # Only back up if we haven't already if not backup_file.exists(): backup_file.write_text(original_content) # Check if the current content is already our stub if original_content != stub_content: print(f"[setup] Replacing {init_file} with minimal stub " f"(original backed up at {backup_file})") init_file.write_text(stub_content) else: print(f"[setup] Creating minimal {init_file}") init_file.write_text(stub_content) # Also replace vibevoice/modular/__init__.py if it imports streaming classes modular_init = vv_pkg_dir / "modular" / "__init__.py" modular_backup = vv_pkg_dir / "modular" / "__init__.py.original" if modular_init.exists(): modular_content = modular_init.read_text() # If it imports streaming classes, replace with empty stub if "streaming" in modular_content.lower(): if not modular_backup.exists(): modular_backup.write_text(modular_content) print(f"[setup] Replacing {modular_init} with empty stub " f"(original backed up at {modular_backup})") modular_init.write_text( "# Auto-generated stub by surgery.py\n" "# The original modular/__init__.py imported streaming classes\n" "# that may not exist in all forks. Surgery.py imports the\n" "# needed modules explicitly.\n" ) else: # Create empty __init__.py modular_init.write_text( "# Auto-generated stub by surgery.py\n" ) # Same for processor/__init__.py if needed processor_init = vv_pkg_dir / "processor" / "__init__.py" if processor_init.exists(): processor_content = processor_init.read_text() if "streaming" in processor_content.lower() or "VibeVoiceStreamingProcessor" in processor_content: processor_backup = vv_pkg_dir / "processor" / "__init__.py.original" if not processor_backup.exists(): processor_backup.write_text(processor_content) print(f"[setup] Replacing {processor_init} with empty stub " f"(original backed up at {processor_backup})") processor_init.write_text( "# Auto-generated stub by surgery.py\n" ) else: processor_init.write_text("# Auto-generated stub by surgery.py\n") # Pre-patch AutoModel.register / AutoModelForCausalLM.register to be # tolerant of re-registration (newer transformers raises if a config is # already registered; VibeVoice's modular files don't pass exist_ok=True). # This MUST happen before importing vibevoice's modular modules. _patch_auto_register_tolerant() # Patch transformers 5.x breaking changes that VibeVoice's source code # does not yet handle. _patch_transformers_5x_compat() # IMPORTANT: transformers >= 5.x ships its own (incompatible) VibeVoice # implementation. We MUST force AutoModel / AutoConfig to use the user's # local VibeVoice classes instead of the builtin ones, otherwise loading # the user's checkpoint fails with attribute errors. _override_builtin_vibevoice_classes() # Sanity-check that the package is importable (with the stub __init__.py, # this should NOT trigger streaming imports) try: import vibevoice # noqa: F401 except ImportError as e: raise ImportError( f"Cannot import the 'vibevoice' package even after adding " f"{repo_root} to sys.path and stubbing __init__.py. " f"Original error: {e}" ) # Importing these modules triggers the AutoModel.register() calls inside # them, so that VibeVoiceConfig becomes a known config class. from vibevoice.modular import configuration_vibevoice # noqa: F401 from vibevoice.modular import modeling_vibevoice # noqa: F401 from vibevoice.modular import modular_vibevoice_tokenizer # noqa: F401 from vibevoice.modular import modular_vibevoice_diffusion_head # noqa: F401 from vibevoice.modular import modular_vibevoice_text_tokenizer # noqa: F401 # Re-override AFTER the user's modular files are imported, because their # register() calls (which we made idempotent above) won't replace the # builtin mappings. _override_builtin_vibevoice_classes() # IMPORTANT: Patch VibeVoiceConfig so it accepts qwen3_5_text as a decoder # type (the upstream code only accepts qwen2). _patch_vibevoice_config_for_qwen35() print(f"[setup] VibeVoice modules loaded from {repo_root}") _AUTO_PATCHED = False def _patch_auto_register_tolerant() -> None: """Make AutoModel.register / AutoModelForCausalLM.register idempotent.""" global _AUTO_PATCHED if _AUTO_PATCHED: return from transformers.models.auto.auto_factory import _LazyAutoMapping original_register = _LazyAutoMapping.register def tolerant_register(self, config_class, model_class, exist_ok=True): try: return original_register(self, config_class, model_class, exist_ok=exist_ok) except ValueError: # Already registered -- skip silently. return None _LazyAutoMapping.register = tolerant_register _AUTO_PATCHED = True print("[setup] Patched AutoModel.register to be idempotent") _COMPAT_PATCHED = False def _patch_transformers_5x_compat() -> None: """ Apply compatibility shims for transformers 5.x breaking changes that VibeVoice's source code does not yet handle: 1. `transformers.models.qwen2.tokenization_qwen2_fast` was removed in transformers 5.x (Qwen2TokenizerFast now lives in tokenization_qwen2). We inject a synthetic module that re-exports the merged class so the VibeVoice `from ... import Qwen2TokenizerFast` keeps working. Idempotent. """ global _COMPAT_PATCHED if _COMPAT_PATCHED: return import types import transformers.models.qwen2 as qwen2_pkg from transformers.models.qwen2 import tokenization_qwen2 # 1. Inject a synthetic `tokenization_qwen2_fast` module that re-exports # the (merged) Qwen2TokenizerFast from tokenization_qwen2. fast_mod = types.ModuleType("transformers.models.qwen2.tokenization_qwen2_fast") # The merged class might be called Qwen2Tokenizer (the only one that exists # in 5.x) — alias it as Qwen2TokenizerFast for backward compatibility. fast_mod.Qwen2TokenizerFast = ( getattr(tokenization_qwen2, "Qwen2TokenizerFast", None) or tokenization_qwen2.Qwen2Tokenizer ) fast_mod.Qwen2Tokenizer = tokenization_qwen2.Qwen2Tokenizer sys.modules["transformers.models.qwen2.tokenization_qwen2_fast"] = fast_mod # Also expose as attribute of the parent package qwen2_pkg.tokenization_qwen2_fast = fast_mod _COMPAT_PATCHED = True print("[setup] Patched transformers 5.x qwen2 tokenizer compat") _OVERRIDE_PATCHED = False def _override_builtin_vibevoice_classes() -> None: """ Force AutoModel.from_config (and AutoModelForCausalLM.from_pretrained) to use the user's local VibeVoice classes instead of the (incompatible) builtin ones shipped with transformers 5.x. transformers >= 5.x ships its own `VibeVoiceAcousticTokenizerConfig` / `VibeVoiceAcousticTokenizerModel` etc., but with a DIFFERENT API than the user's local code (e.g. `encoder_config` vs `encoder_n_filters`). If we let AutoModel pick the builtin class, loading the user's checkpoint fails with attribute errors. Implementation: we monkey-patch AutoModel.from_config to check whether the passed config is one of the user's VibeVoice config classes. If yes, we instantiate the user's model class directly. Otherwise, we delegate to the original AutoModel.from_config (so non-VibeVoice models are unaffected). AutoModelForCausalLM.from_pretrained is similarly patched to route VibeVoice checkpoints to the user's VibeVoiceForConditionalGeneration class. Idempotent. """ global _OVERRIDE_PATCHED try: from vibevoice.modular.configuration_vibevoice import ( VibeVoiceConfig, VibeVoiceAcousticTokenizerConfig, VibeVoiceSemanticTokenizerConfig, VibeVoiceDiffusionHeadConfig, ) except ImportError: # Not imported yet -- can't override. Will be retried after import. return if _OVERRIDE_PATCHED: return from transformers.models.auto import AutoModel, AutoModelForCausalLM # Mapping from the user's config class -> user's model class # (filled in lazily because some model files may not be importable yet) _USER_MODEL_CLASSES: Dict[type, type] = {} def _ensure_user_classes_loaded() -> None: if _USER_MODEL_CLASSES: return from vibevoice.modular.modular_vibevoice_tokenizer import ( VibeVoiceAcousticTokenizerModel, VibeVoiceSemanticTokenizerModel, ) from vibevoice.modular.modular_vibevoice_diffusion_head import ( VibeVoiceDiffusionHead, ) from vibevoice.modular.modeling_vibevoice import ( VibeVoiceModel, VibeVoiceForConditionalGeneration, ) _USER_MODEL_CLASSES.update({ VibeVoiceAcousticTokenizerConfig: VibeVoiceAcousticTokenizerModel, VibeVoiceSemanticTokenizerConfig: VibeVoiceSemanticTokenizerModel, VibeVoiceDiffusionHeadConfig: VibeVoiceDiffusionHead, VibeVoiceConfig: VibeVoiceModel, }) # Cache the CausalLM class too _USER_MODEL_CLASSES["__causal_lm__"] = VibeVoiceForConditionalGeneration # --- Patch AutoModel.from_config --- _orig_automodel_from_config = AutoModel.from_config def _patched_from_config(config, *args, **kwargs): _ensure_user_classes_loaded() # Check by identity (config is an INSTANCE of one of the user's classes) for user_cfg_cls, user_mdl_cls in _USER_MODEL_CLASSES.items(): if not isinstance(user_cfg_cls, type): continue # skip non-type keys like "__causal_lm__" if isinstance(config, user_cfg_cls): return user_mdl_cls._from_config(config, *args, **kwargs) # Fallback: also check by class name (in case the config is a # transformers-builtin VibeVoice config that we want to redirect # to the user's class). Built lazily from _USER_MODEL_CLASSES. cfg_cls_name = type(config).__name__ name_to_model = { "VibeVoiceAcousticTokenizerConfig": _USER_MODEL_CLASSES[VibeVoiceAcousticTokenizerConfig], "VibeVoiceSemanticTokenizerConfig": _USER_MODEL_CLASSES[VibeVoiceSemanticTokenizerConfig], "VibeVoiceDiffusionHeadConfig": _USER_MODEL_CLASSES[VibeVoiceDiffusionHeadConfig], "VibeVoiceConfig": _USER_MODEL_CLASSES[VibeVoiceConfig], } if cfg_cls_name in name_to_model: user_mdl_cls = name_to_model[cfg_cls_name] return user_mdl_cls._from_config(config, *args, **kwargs) return _orig_automodel_from_config(config, *args, **kwargs) AutoModel.from_config = staticmethod(_patched_from_config) # --- Patch AutoModelForCausalLM.from_pretrained --- _orig_causallm_from_pretrained = AutoModelForCausalLM.from_pretrained def _patched_causallm_from_pretrained(cls, pretrained_model_name_or_path, *args, **kwargs): _ensure_user_classes_loaded() # Inspect the config to decide whether to route to the user's class from transformers import AutoConfig try: cfg = AutoConfig.from_pretrained(pretrained_model_name_or_path, **{ k: v for k, v in kwargs.items() if k in ("cache_dir", "trust_remote_code", "revision", "use_auth_token") }) except Exception: cfg = None # Check if the loaded config is (or should be) a VibeVoice config is_vibevoice = False if cfg is not None: if isinstance(cfg, VibeVoiceConfig): is_vibevoice = True elif type(cfg).__name__ in ( "VibeVoiceConfig", "VibeVoiceForConditionalGeneration", ): is_vibevoice = True elif getattr(cfg, "model_type", "") in ("vibevoice", "vibepod"): is_vibevoice = True if is_vibevoice: user_cls = _USER_MODEL_CLASSES.get("__causal_lm__") if user_cls is not None: return user_cls.from_pretrained(pretrained_model_name_or_path, *args, **kwargs) # Call the original classmethod with cls as the first arg if hasattr(_orig_causallm_from_pretrained, "__func__"): return _orig_causallm_from_pretrained.__func__(cls, pretrained_model_name_or_path, *args, **kwargs) return _orig_causallm_from_pretrained(pretrained_model_name_or_path, *args, **kwargs) AutoModelForCausalLM.from_pretrained = classmethod(_patched_causallm_from_pretrained) # --- Also patch AutoConfig.from_pretrained to redirect VibeVoice configs --- from transformers import AutoConfig _orig_autoconfig_from_pretrained = AutoConfig.from_pretrained def _patched_autoconfig_from_pretrained(cls, pretrained_model_name_or_path, *args, **kwargs): cfg = _orig_autoconfig_from_pretrained.__func__(cls, pretrained_model_name_or_path, *args, **kwargs) \ if hasattr(_orig_autoconfig_from_pretrained, "__func__") \ else _orig_autoconfig_from_pretrained(pretrained_model_name_or_path, *args, **kwargs) # If the config is a transformers-builtin VibeVoice config (because # the model_type matched the builtin), rebuild it as the user's config. cfg_type_name = type(cfg).__name__ builtin_vibevoice_names = { "VibeVoiceAcousticTokenizerConfig", "VibeVoiceSemanticTokenizerConfig", "VibeVoiceDiffusionHeadConfig", "VibeVoiceConfig", } if cfg_type_name in builtin_vibevoice_names: # Get the user's config class user_cfg_cls = { "VibeVoiceAcousticTokenizerConfig": VibeVoiceAcousticTokenizerConfig, "VibeVoiceSemanticTokenizerConfig": VibeVoiceSemanticTokenizerConfig, "VibeVoiceDiffusionHeadConfig": VibeVoiceDiffusionHeadConfig, "VibeVoiceConfig": VibeVoiceConfig, }[cfg_type_name] # Build a new config of the user's class from the dict try: cfg_dict = cfg.to_dict() # Remove keys that may confuse the user's __init__ for k in ("model_type", "transformers_version"): cfg_dict.pop(k, None) # The user's VibeVoiceConfig __init__ takes specific kwargs; # if it raises, we just return the original (builtin) config # and let downstream handle it. return user_cfg_cls(**cfg_dict) except Exception as e: print(f"[setup] WARN: could not rebuild config as user's class: {e}") return cfg return cfg AutoConfig.from_pretrained = classmethod(_patched_autoconfig_from_pretrained) # --- Patch _tied_weights_keys format for transformers 5.x --- # In transformers 5.x, _tied_weights_keys is a DICT (target -> source), # but the user's VibeVoice code declares it as a LIST ["lm_head.weight"]. # This causes a crash in get_expanded_tied_weights_keys. try: from vibevoice.modular.modeling_vibevoice import ( VibeVoiceForConditionalGeneration as _VVCFG, ) # Convert list to dict {target: source} where source is the input # embeddings key. _VVCFG._tied_weights_keys = {"lm_head.weight": "model.embed_tokens.weight"} # --- Patch tie_weights signature for transformers 5.x --- # In transformers 5.x, PreTrainedModel.init_weights calls # self.tie_weights(recompute_mapping=False), and _finalize_model_loading # calls self.tie_weights(missing_keys=..., recompute_mapping=False). # The user's VibeVoiceForConditionalGeneration.tie_weights() doesn't # accept these kwargs. Wrap it to accept and ignore the extras. _orig_tie_weights_cfg = _VVCFG.tie_weights def _patched_tie_weights_cfg(self, *args, **kwargs): # Accept and ignore transformers 5.x kwargs kwargs.pop("recompute_mapping", None) kwargs.pop("missing_keys", None) return _orig_tie_weights_cfg(self, *args, **kwargs) _VVCFG.tie_weights = _patched_tie_weights_cfg print("[setup] Patched VibeVoiceForConditionalGeneration.tie_weights for transformers 5.x") # Also patch the inference variant if it's importable. # IMPORTANT: VibeVoiceForConditionalGenerationInference has its OWN # tie_weights method (it doesn't inherit from VibeVoiceForConditionalGeneration), # so we must patch it separately. try: from vibevoice.modular.modeling_vibevoice_inference import ( VibeVoiceForConditionalGenerationInference as _VVInfCFG, ) _VVInfCFG._tied_weights_keys = {"lm_head.weight": "model.embed_tokens.weight"} _orig_tie_weights_inf = _VVInfCFG.tie_weights def _patched_tie_weights_inf(self, *args, **kwargs): kwargs.pop("recompute_mapping", None) kwargs.pop("missing_keys", None) return _orig_tie_weights_inf(self, *args, **kwargs) _VVInfCFG.tie_weights = _patched_tie_weights_inf print("[setup] Patched VibeVoiceForConditionalGenerationInference.tie_weights for transformers 5.x") except ImportError: # modeling_vibevoice_inference.py not present in this fork pass except ImportError as e: print(f"[setup] WARN: could not patch _tied_weights_keys: {e}") # --- Patch DPMSolverMultistepScheduler for transformers 5.x --- # In transformers 5.x, from_pretrained may run model __init__ under a # `torch.device("meta")` context manager, which makes all tensor creation # happen on the meta device. The DPMSolverMultistepScheduler in VibeVoice's # schedule/dpm_solver.py does `self.sigmas = self.sigmas.to("cpu")`, which # fails because meta tensors cannot be copied out. # Fix: wrap the scheduler's __init__ to escape the meta device context. try: from vibevoice.schedule.dpm_solver import DPMSolverMultistepScheduler as _DPM _orig_dpm_init = _DPM.__init__ def _patched_dpm_init(self, *args, **kwargs): # Temporarily exit any meta device context by using torch.device("cpu") # as the active device during init. with torch.device("cpu"): return _orig_dpm_init(self, *args, **kwargs) _DPM.__init__ = _patched_dpm_init print("[setup] Patched DPMSolverMultistepScheduler.__init__ for meta device") except ImportError as e: print(f"[setup] WARN: could not patch DPMSolverMultistepScheduler: {e}") # --- Patch GenerationMixin._prepare_generation_config for transformers 5.x --- # VibeVoice's inference code calls: # self._prepare_generation_config(generation_config, True, speech_start_id=..., ...) # In transformers 4.x, the signature was: # _prepare_generation_config(self, generation_config, copy=True, **kwargs) # In transformers 5.x, the `copy` parameter was removed: # _prepare_generation_config(self, generation_config, **kwargs) # This causes: TypeError: takes 2 positional arguments but 3 were given # Fix: wrap the method to accept and ignore the extra positional `copy` arg. try: from transformers.generation.utils import GenerationMixin _orig_prepare_gen_config = GenerationMixin._prepare_generation_config def _patched_prepare_generation_config(self, generation_config, *args, **kwargs): # In transformers 5.x, there's no `copy` positional arg. # VibeVoice passes `True` as the second positional arg (the old `copy`). # We just ignore it — the new transformers always copies internally. return _orig_prepare_gen_config(self, generation_config, **kwargs) GenerationMixin._prepare_generation_config = _patched_prepare_generation_config print("[setup] Patched GenerationMixin._prepare_generation_config for transformers 5.x") except (ImportError, AttributeError) as e: print(f"[setup] WARN: could not patch _prepare_generation_config: {e}") # --- Patch GenerationMixin._prepare_cache_for_generation for transformers 5.x --- # VibeVoice's inference code calls (6 positional args after self): # self._prepare_cache_for_generation(generation_config, model_kwargs, None, batch_size, max_cache_length, device) # In transformers 5.x, the signature is (5 positional args after self, no `device`): # _prepare_cache_for_generation(self, generation_config, model_kwargs, generation_mode, batch_size, max_cache_length) -> bool # The `device` arg was removed in 5.x. We patch the method to accept and # ignore the extra `device` arg, and return True (the new return value). # # CRITICAL FIX for Qwen3.5 hybrid attention: # We also ensure the DynamicCache is created with the REAL decoder config # (not the VibeVoiceConfig wrapper). This is needed because Qwen3.5 uses # hybrid attention (LinearAttention + FullAttention), and the DynamicCache # must know the `layer_types` to create the correct mix of cache layers. # Without this, all cache layers are created as DynamicLayer (full_attention), # and `has_previous_state()` raises: # ValueError: `has_previous_state` can only be called on LinearAttention # layers, and the current Cache seem to only contain Attention layers. try: _orig_prepare_cache = GenerationMixin._prepare_cache_for_generation def _patched_prepare_cache_for_generation(self, generation_config, model_kwargs, *args, **kwargs): # VibeVoice passes (generation_config, model_kwargs, None, batch_size, max_cache_length, device) # New API expects (generation_config, model_kwargs, generation_mode, batch_size, max_cache_length) # args = (None, batch_size, max_cache_length, device) from VibeVoice # We need to pass only the first 3 of args (None, batch_size, max_cache_length) # and drop the `device`. if len(args) > 3: # VibeVoice style: drop the extra `device` arg args = args[:3] result = _orig_prepare_cache(self, generation_config, model_kwargs, *args, **kwargs) # --- Belt-and-suspenders fix for Qwen3.5 hybrid attention cache --- # After the original method creates the cache, verify it has the # correct layer types. If the cache was created with the wrong # config (e.g., VibeVoiceConfig instead of decoder_config), and # the decoder uses hybrid attention (layer_types includes # "linear_attention"), recreate the cache with the correct config. cache_name = "past_key_values" pkv = model_kwargs.get(cache_name) if pkv is not None and hasattr(pkv, "layers") and len(pkv.layers) > 0: # Check if the decoder has hybrid attention dec_cfg = getattr(self.config, "decoder_config", None) if dec_cfg is not None: dec_layer_types = getattr(dec_cfg, "layer_types", None) if dec_layer_types and any( lt == "linear_attention" for lt in dec_layer_types ): # The decoder uses hybrid attention. Check if the cache # has any LinearAttention layers. from transformers.cache_utils import ( LinearAttentionCacheLayerMixin as _LAC, ) has_linear = any( isinstance(l, _LAC) for l in pkv.layers ) if not has_linear: # The cache was created without LinearAttention # layers. Recreate it with the real decoder config. from transformers import DynamicCache as _DC new_cache = _DC(config=dec_cfg) model_kwargs[cache_name] = new_cache return result GenerationMixin._prepare_cache_for_generation = _patched_prepare_cache_for_generation print("[setup] Patched GenerationMixin._prepare_cache_for_generation for transformers 5.x") except (ImportError, AttributeError) as e: print(f"[setup] WARN: could not patch _prepare_cache_for_generation: {e}") # --- Patch _init_weights to be a no-op for non-diffusion-head modules # when called from `initialize_weights` (post-state_dict-load). # In transformers 5.x, `from_pretrained` calls `initialize_weights` which # applies `_initialize_weights` to every module. For non-remote-code models # (our case), the `_is_hf_initialized` flag is NOT checked at the module # level, so `_init_weights` is called on every module, re-randomizing the # loaded weights! The intended mechanism is that `init.guard_torch_init_functions` # intercepts torch's init functions and checks the param-level flag, but # VibeVoice's `_init_weights` uses `module.weight.data.normal_(...)` which # may not be intercepted. To be safe, we make `_init_weights` a no-op for # Linear/Embedding/LayerNorm modules after the model is constructed. try: from vibevoice.modular.modeling_vibevoice import VibeVoicePreTrainedModel _orig_vv_init_weights = VibeVoicePreTrainedModel._init_weights # We use a thread-local flag to indicate whether we're in the # post-load init phase. The flag is set by a wrapper around # `initialize_weights` and unset after. import threading _init_state = threading.local() _init_state.in_post_load_init = False def _patched_vv_init_weights(self, module): # Always allow VibeVoiceDiffusionHead initialization from vibevoice.modular.modular_vibevoice_diffusion_head import VibeVoiceDiffusionHead if isinstance(module, VibeVoiceDiffusionHead): module.initialize_weights() return # During post-load init, skip re-initialization for modules that # already have their params loaded (i.e. have _is_hf_initialized # on at least one param). if getattr(_init_state, "in_post_load_init", False): # Check if any param of this module has _is_hf_initialized has_loaded_param = any( getattr(p, "_is_hf_initialized", False) for p in module.parameters(recurse=False) ) if has_loaded_param: return # skip re-init # Otherwise, call the original init _orig_vv_init_weights(self, module) VibeVoicePreTrainedModel._init_weights = _patched_vv_init_weights # Wrap `initialize_weights` to set the post-load flag _orig_vv_initialize_weights = VibeVoicePreTrainedModel.initialize_weights def _patched_vv_initialize_weights(self): _init_state.in_post_load_init = True try: return _orig_vv_initialize_weights(self) finally: _init_state.in_post_load_init = False VibeVoicePreTrainedModel.initialize_weights = _patched_vv_initialize_weights print("[setup] Patched VibeVoicePreTrainedModel._init_weights to preserve loaded weights") except ImportError as e: print(f"[setup] WARN: could not patch VibeVoicePreTrainedModel._init_weights: {e}") # --- Patch VibeVoiceTokenizerEncoderOutput to be subscriptable --- # The VibeVoice source code in modeling_vibevoice.py:291 does: # frames = self.model.acoustic_tokenizer.encode(speech_tensors.unsqueeze(1))[0][0] # audio_tokens = frames.sample(self.model.acoustic_tokenizer.std_dist_type)[0] # This assumes encode() returns a nested tuple where [0][0] extracts the # EncoderOutput object. However, the current VibeVoice source defines # encode() to return a VibeVoiceTokenizerEncoderOutput dataclass directly # (with .mean, .std, and .sample() attributes), which is NOT subscriptable. # This is an internal VibeVoice bug — the caller and callee were updated at # different times and are now incompatible. # # Fix: add __getitem__ to VibeVoiceTokenizerEncoderOutput so that [0] and # [0][0] both return self (the EncoderOutput object). This way: # encode(...)[0] -> self (the EncoderOutput) # encode(...)[0][0] -> self[0] -> self (the EncoderOutput) # frames.sample(...) -> calls .sample() on the EncoderOutput ✓ # This preserves the caller's intent without modifying VibeVoice's source. try: from vibevoice.modular.modular_vibevoice_tokenizer import VibeVoiceTokenizerEncoderOutput if not hasattr(VibeVoiceTokenizerEncoderOutput, "__getitem__"): def _encoder_output_getitem(self, index): """Make the dataclass subscriptable like the old tuple-based API. [0] -> self (the EncoderOutput object, which has .sample()) [1] -> self.std Any integer index returns self so that [0][0] chaining works. """ if index == 0: return self # Return self so [0][0] still gives self, # and frames.sample() works on the EncoderOutput elif index == 1: return self.std else: return self # Be lenient: return self for any index VibeVoiceTokenizerEncoderOutput.__getitem__ = _encoder_output_getitem print("[setup] Patched VibeVoiceTokenizerEncoderOutput.__getitem__ " "for tuple-like access (returns self for [0])") except ImportError as e: print(f"[setup] WARN: could not patch VibeVoiceTokenizerEncoderOutput: {e}") _OVERRIDE_PATCHED = True print("[setup] Overrode builtin VibeVoice classes with user's local ones") _PATCHED = False def _patch_vibevoice_config_for_qwen35() -> None: """ Monkey-patch VibeVoiceConfig so that its __init__ accepts any model_type for the decoder_config (not just 'qwen2'). Without this patch, loading a surgically-modified VibeVoice (which has a qwen3_5_text decoder) would raise: "Unsupported decoder model type: qwen3_5_text". The patch is idempotent (safe to call multiple times). """ global _PATCHED if _PATCHED: return from vibevoice.modular.configuration_vibevoice import VibeVoiceConfig from transformers.models.qwen2.configuration_qwen2 import Qwen2Config from transformers import AutoConfig def patched_init(self, acoustic_tokenizer_config=None, semantic_tokenizer_config=None, decoder_config=None, diffusion_head_config=None, **kwargs): """ Replacement for VibeVoiceConfig.__init__ that accepts ANY decoder model_type (not just 'qwen2'). The original code only supports qwen2. """ # kwargs["_attn_implementation_autoset"] = False -- preserve caller intent kwargs.setdefault("_attn_implementation_autoset", False) # --- acoustic_tokenizer_config --- from vibevoice.modular.configuration_vibevoice import ( VibeVoiceAcousticTokenizerConfig, VibeVoiceSemanticTokenizerConfig, VibeVoiceDiffusionHeadConfig, ) if acoustic_tokenizer_config is None: self.acoustic_tokenizer_config = VibeVoiceAcousticTokenizerConfig() elif isinstance(acoustic_tokenizer_config, dict): d = dict(acoustic_tokenizer_config) d["model_type"] = "vibevoice_acoustic_tokenizer" self.acoustic_tokenizer_config = VibeVoiceAcousticTokenizerConfig(**d) else: self.acoustic_tokenizer_config = acoustic_tokenizer_config # --- semantic_tokenizer_config --- if semantic_tokenizer_config is None: self.semantic_tokenizer_config = VibeVoiceSemanticTokenizerConfig() elif isinstance(semantic_tokenizer_config, dict): d = dict(semantic_tokenizer_config) d["model_type"] = "vibevoice_semantic_tokenizer" self.semantic_tokenizer_config = VibeVoiceSemanticTokenizerConfig(**d) else: self.semantic_tokenizer_config = semantic_tokenizer_config # --- decoder_config (THE KEY CHANGE: support any model_type) --- if decoder_config is None: self.decoder_config = Qwen2Config() elif isinstance(decoder_config, dict): mt = decoder_config.get("model_type", "") if mt == "qwen2": self.decoder_config = Qwen2Config(**decoder_config) elif mt: # Any other model_type: use AutoConfig to build the right class d = dict(decoder_config) d.pop("model_type", None) try: self.decoder_config = AutoConfig.for_model(model_type=mt, **d) except Exception as e: print(f"[patch] Could not build config for model_type='{mt}': {e}") raise else: # No model_type -- assume qwen2 (backwards compat) self.decoder_config = Qwen2Config(**decoder_config) else: # Already a config object self.decoder_config = decoder_config # --- diffusion_head_config --- if diffusion_head_config is None: self.diffusion_head_config = VibeVoiceDiffusionHeadConfig() elif isinstance(diffusion_head_config, dict): d = dict(diffusion_head_config) d["model_type"] = "vibevoice_diffusion_head" self.diffusion_head_config = VibeVoiceDiffusionHeadConfig(**d) else: self.diffusion_head_config = diffusion_head_config # Other parameters self.acoustic_vae_dim = getattr(self.acoustic_tokenizer_config, 'vae_dim', 64) self.semantic_vae_dim = getattr(self.semantic_tokenizer_config, 'vae_dim', 128) # Call PreTrainedConfig.__init__ to handle remaining kwargs # (vocab_size, tie_word_embeddings, torch_dtype, etc.) super(VibeVoiceConfig, self).__init__(**kwargs) # --- Expose decoder_config attributes at the top level for transformers 5.x --- # transformers 5.x's cache utilities (DynamicCache, etc.) access # `config.num_hidden_layers`, `config.hidden_size`, etc. directly on the # top-level config. VibeVoiceConfig is a composite config that stores # these in `self.decoder_config`, so we need to expose them as # pass-through properties. dec = self.decoder_config for attr in ("num_hidden_layers", "hidden_size", "num_attention_heads", "num_key_value_heads", "head_dim", "intermediate_size", "vocab_size", "max_position_embeddings", "rms_norm_eps", "tie_word_embeddings", "layer_types"): if hasattr(dec, attr) and not hasattr(self, attr): try: setattr(self, attr, getattr(dec, attr)) except Exception: pass # some attributes may be read-only VibeVoiceConfig.__init__ = patched_init # --- Override get_text_config to return decoder_config for decoder=True --- # This is CRITICAL for Qwen3.5 hybrid attention models. # # transformers 5.x's DynamicCache.__init__ does: # decoder_config = config.get_text_config(decoder=True) # layer_types = getattr(decoder_config, "layer_types", None) # # The default get_text_config(decoder=True) looks for attributes named # "decoder", "generator", or "text_config". VibeVoiceConfig stores its # decoder config as "decoder_config" (not "decoder"), so the default # implementation returns `self` (the VibeVoiceConfig) instead of the # real Qwen3.5 text config. # # While the patched __init__ above DOES propagate `layer_types` to the # top level, this propagation can be fragile: # - It depends on `setattr` succeeding (some attributes may be read-only) # - It depends on `from_pretrained` calling the patched __init__ # - Different transformers versions may handle config loading differently # # By overriding get_text_config, we ensure DynamicCache ALWAYS gets the # real Qwen3.5 text config (with layer_types properly set), eliminating # the "has_previous_state can only be called on LinearAttention layers" # error that occurs when the cache is created without LinearAttention # layers. def patched_get_text_config(self, decoder=None, encoder=None): """ Return the decoder's text config when decoder=True. For VibeVoice, the decoder config is self.decoder_config. """ if decoder is True: # Return the real decoder config (Qwen3.5 text config) if hasattr(self, "decoder_config") and self.decoder_config is not None: return self.decoder_config # For other cases (encoder=True, or both unset), fall back to the # original implementation return _orig_get_text_config(self, decoder=decoder, encoder=encoder) _orig_get_text_config = VibeVoiceConfig.get_text_config VibeVoiceConfig.get_text_config = patched_get_text_config _PATCHED = True print("[setup] Patched VibeVoiceConfig to support qwen3_5_text decoder") # --- Also patch VibeVoiceStreamingConfig (if it exists) --- # The Microsoft VibeVoice repo has a VibeVoiceStreamingConfig that has the # same "Unsupported decoder model type" issue. We patch it the same way. try: from vibevoice.modular.configuration_vibevoice_streaming import ( VibeVoiceStreamingConfig as _VVStreamingConfig, ) _orig_streaming_init = _VVStreamingConfig.__init__ def _patched_streaming_init(self, *args, **kwargs): from transformers import AutoConfig # Pre-convert decoder_config dict -> config object if "decoder_config" in kwargs and isinstance(kwargs["decoder_config"], dict): dc = kwargs["decoder_config"] mt = dc.get("model_type", "") if mt and mt != "qwen2": try: dc_clean = dict(dc) dc_clean.pop("model_type", None) kwargs["decoder_config"] = AutoConfig.for_model( model_type=mt, **dc_clean ) except Exception as e: print(f"[patch] Streaming config: AutoConfig.for_model " f"failed for '{mt}': {e}") # Temporarily make the isinstance check accept our config class from vibevoice.modular import configuration_vibevoice_streaming as _vv_str_mod from transformers.models.qwen2.configuration_qwen2 import Qwen2Config _orig_qwen2cls = getattr(_vv_str_mod, "Qwen2Config", Qwen2Config) dec_cfg = kwargs.get("decoder_config", None) if dec_cfg is not None and not isinstance(dec_cfg, dict): _vv_str_mod.Qwen2Config = (Qwen2Config, type(dec_cfg)) try: _orig_streaming_init(self, *args, **kwargs) finally: _vv_str_mod.Qwen2Config = _orig_qwen2cls # If decoder_config is still a dict, forcibly set it if not hasattr(self, "decoder_config") or self.decoder_config is None: dec_cfg = kwargs.get("decoder_config", None) if dec_cfg is not None: self.decoder_config = dec_cfg else: self.decoder_config = Qwen2Config() _VVStreamingConfig.__init__ = _patched_streaming_init print("[setup] Patched VibeVoiceStreamingConfig to support qwen3_5_text decoder") except ImportError: # The streaming config doesn't exist in this fork — skip pass # ============================================================================ # Section 3: Low-level weight expansion utilities # ============================================================================ @torch.no_grad() def expand_linear_zero_pad( old_layer: nn.Linear, new_in_features: int, new_out_features: int, bias: Optional[bool] = None, init_new_input: str = "zero", ) -> nn.Linear: """ Build a new nn.Linear(new_in, new_out) whose top-left (old_in, old_out) block equals the old layer's weights, and whose new rows / columns are zero- (or optionally small-random-) initialised. Args: old_layer: source nn.Linear; must have weight shape (old_out, old_in). new_in_features: expanded input dim (>= old_in). new_out_features: expanded output dim (>= old_out). bias: whether the new layer should have a bias. If None (default), the bias flag is INHERITED from old_layer: if old_layer.bias is not None, the new layer also has a bias, and the old bias values are copied (with zero-padding for the new output positions). This preserves the original biases for the preserved output dims and zero-inits the new dims. If True/False, that value is used explicitly. init_new_input: "zero" -> new input columns are zero "small" -> new input columns are N(0, 1/sqrt(new_in)) Returns: A new nn.Linear with the expanded weights loaded. NOTE: The previous default was `bias=False`, which silently dropped the biases of the speech-connector fc1/fc2 and the diffusion-head FFN layers. This caused the LOAD REPORT to flag `fc1.bias` / `fc2.bias` as MISSING after surgery, and the biases were then re-initialised by `_init_weights`, losing the pretrained bias values for the preserved output dims. """ old_out, old_in = old_layer.weight.shape if new_in_features < old_in or new_out_features < old_out: raise ValueError( f"Cannot shrink layer: old=({old_in},{old_out}) " f"new=({new_in_features},{new_out_features})" ) # Inherit bias flag from old_layer if not explicitly specified. # This fixes the bug where expand_speech_connector / expand_head_layer / # expand_final_layer / expand_timestep_embedder previously built new # Linear layers with bias=False even when the original had bias=True. if bias is None: bias = old_layer.bias is not None # Build new layer in the same dtype/device as the old one new_layer = nn.Linear( new_in_features, new_out_features, bias=bias, device=old_layer.weight.device, dtype=old_layer.weight.dtype, ) # Zero everything first (this covers new rows AND new columns AND any bias) new_layer.weight.data.zero_() # Copy the old (old_out, old_in) block into the top-left new_layer.weight.data[:old_out, :old_in].copy_(old_layer.weight.data) # Optionally fill the new input columns with small random values so that # the new dims can start learning immediately (does NOT change behaviour # on the preserved dims because the new OUTPUT rows are still zero). if init_new_input == "small" and new_in_features > old_in: std = 1.0 / math.sqrt(new_in_features) new_layer.weight.data[:old_out, old_in:].normal_(mean=0.0, std=std) # Copy bias if it exists in both. The new bias positions (old_out:new_out) # remain zero, consistent with the zero-pad strategy: the new output dims # contribute nothing to downstream computation until fine-tuning moves them # away from zero. if bias: # Always zero the new bias first (nn.Linear's default init leaves it # non-zero). If we have an old bias, copy its values into the top-left # block; otherwise leave the whole bias zero (zero-pad strategy). new_layer.bias.data.zero_() if old_layer.bias is not None: new_layer.bias.data[:old_out].copy_(old_layer.bias.data) return new_layer @torch.no_grad() def expand_rmsnorm( old_norm: nn.Module, new_dim: int, eps: Optional[float] = None, ) -> nn.Module: """ Expand an RMSNorm-like module from old_dim to new_dim. The new weights are: [old_weights (copied), 1.0, 1.0, ...] (1.0 because that is the identity contribution for the new dims). Works with both LlamaRMSNorm (transformers) and the custom RMSNorm defined in modular_vibevoice_diffusion_head.py. """ # Detect old dim if not hasattr(old_norm, "weight"): raise ValueError(f"Module {type(old_norm)} has no 'weight' attribute.") old_dim = old_norm.weight.shape[0] if new_dim < old_dim: raise ValueError(f"Cannot shrink RMSNorm: {old_dim} -> {new_dim}") # Find eps if eps is None: eps = getattr(old_norm, "eps", 1e-6) # Build a new module of the same type norm_cls = type(old_norm) try: new_norm = norm_cls(new_dim, eps=eps) except TypeError: # Some custom RMSNorm variants have extra kwargs new_norm = norm_cls(new_dim, eps=eps, elementwise_affine=True) # Move to same device/dtype as old new_norm = new_norm.to(device=old_norm.weight.device, dtype=old_norm.weight.dtype) # Initialize all weights to 1.0 new_norm.weight.data.fill_(1.0) # Copy old weights into the first old_dim entries new_norm.weight.data[:old_dim].copy_(old_norm.weight.data) return new_norm @torch.no_grad() def reinit_linear_like_old( layer: nn.Linear, std: float = 0.02, ) -> None: """ Re-initialise a Linear layer in place using the same scheme as VibeVoicePreTrainedModel._init_weights (normal_ with std=0.02). """ layer.weight.data.normal_(mean=0.0, std=std) if layer.bias is not None: layer.bias.data.zero_() # ============================================================================ # Section 4: Surgery primitives for the speech connectors and diffusion head # ============================================================================ @torch.no_grad() def expand_speech_connector( old_connector: nn.Module, new_output_dim: int, name: str = "speech_connector", ) -> nn.Module: """ Expand a SpeechConnector(input_dim, output_dim) from old_output_dim to new_output_dim. The connector structure is: fc1: Linear(input_dim, output_dim) norm: LlamaRMSNorm(output_dim, eps=1e-6) fc2: Linear(output_dim, output_dim) Strategy: - fc1: Linear(in_vae, 1536) -> Linear(in_vae, 2560) * input dim unchanged, output dim zero-padded - norm: RMSNorm(1536) -> RMSNorm(2560) (copy old, 1.0 for new) - fc2: Linear(1536, 1536) -> Linear(2560, 2560) * both dims expanded; top-left block copied, rest zero """ # Re-import locally so callers don't have to depend on VibeVoice at import time from vibevoice.modular.modeling_vibevoice import SpeechConnector old_output_dim = old_connector.fc1.out_features input_dim = old_connector.fc1.in_features if new_output_dim <= old_output_dim: raise ValueError( f"Cannot shrink connector: {old_output_dim} -> {new_output_dim}" ) print(f" [{name}] fc1: Linear({input_dim},{old_output_dim}) " f"-> Linear({input_dim},{new_output_dim}) (zero-pad output)") print(f" [{name}] norm: RMSNorm({old_output_dim}) " f"-> RMSNorm({new_output_dim}) (copy + 1.0 for new)") print(f" [{name}] fc2: Linear({old_output_dim},{old_output_dim}) " f"-> Linear({new_output_dim},{new_output_dim}) (zero-pad in+out)") # Build new connector (random init, we'll overwrite below) new_connector = SpeechConnector(input_dim, new_output_dim) new_connector = new_connector.to( device=old_connector.fc1.weight.device, dtype=old_connector.fc1.weight.dtype, ) # fc1: input dim unchanged, output dim expanded -> zero-pad output rows new_connector.fc1 = expand_linear_zero_pad( old_connector.fc1, new_in_features=input_dim, new_out_features=new_output_dim ) # norm: expand RMSNorm new_connector.norm = expand_rmsnorm(old_connector.norm, new_output_dim, eps=1e-6) # fc2: both dims expanded new_connector.fc2 = expand_linear_zero_pad( old_connector.fc2, new_in_features=new_output_dim, new_out_features=new_output_dim, ) return new_connector @torch.no_grad() def expand_timestep_embedder( old_emb: nn.Module, new_hidden: int, ) -> nn.Module: """ Expand a TimestepEmbedder(hidden_size) from old_hidden to new_hidden. Structure: mlp[0]: Linear(freq_emb=256, hidden) -- zero-pad output mlp[1]: SiLU activation (no params) mlp[2]: Linear(hidden, hidden) -- zero-pad in+out """ from vibevoice.modular.modular_vibevoice_diffusion_head import TimestepEmbedder old_hidden = old_emb.mlp[0].out_features freq_emb = old_emb.mlp[0].in_features # 256 print(f" [t_embedder] mlp[0]: Linear({freq_emb},{old_hidden}) " f"-> Linear({freq_emb},{new_hidden}) (zero-pad output)") print(f" [t_embedder] mlp[2]: Linear({old_hidden},{old_hidden}) " f"-> Linear({new_hidden},{new_hidden}) (zero-pad in+out)") new_emb = TimestepEmbedder(new_hidden) new_emb = new_emb.to( device=old_emb.mlp[0].weight.device, dtype=old_emb.mlp[0].weight.dtype, ) new_emb.mlp[0] = expand_linear_zero_pad( old_emb.mlp[0], new_in_features=freq_emb, new_out_features=new_hidden ) new_emb.mlp[2] = expand_linear_zero_pad( old_emb.mlp[2], new_in_features=new_hidden, new_out_features=new_hidden ) # mlp[1] (SiLU) has no params return new_emb @torch.no_grad() def expand_head_layer( old_layer: nn.Module, new_embed_dim: int, new_ffn_dim: int, new_cond_dim: int, norm_eps: float, ) -> nn.Module: """ Expand a HeadLayer(embed_dim, ffn_dim, cond_dim) to the new dims. Structure: ffn.gate_proj: Linear(embed, ffn) -- zero-pad in+out ffn.up_proj: Linear(embed, ffn) -- zero-pad in+out ffn.down_proj: Linear(ffn, embed) -- zero-pad in+out norm: RMSNorm(embed) -- copy + 1.0 for new adaLN_modulation[1]: Linear(cond, 3*embed) -- zero-pad in+out """ from vibevoice.modular.modular_vibevoice_diffusion_head import HeadLayer # Build new layer (random init, we'll overwrite) new_layer = HeadLayer( embed_dim=new_embed_dim, ffn_dim=new_ffn_dim, cond_dim=new_cond_dim, norm_eps=norm_eps, ) new_layer = new_layer.to( device=old_layer.ffn.gate_proj.weight.device, dtype=old_layer.ffn.gate_proj.weight.dtype, ) # FFN: gate_proj, up_proj, down_proj new_layer.ffn.gate_proj = expand_linear_zero_pad( old_layer.ffn.gate_proj, new_in_features=new_embed_dim, new_out_features=new_ffn_dim, ) new_layer.ffn.up_proj = expand_linear_zero_pad( old_layer.ffn.up_proj, new_in_features=new_embed_dim, new_out_features=new_ffn_dim, ) new_layer.ffn.down_proj = expand_linear_zero_pad( old_layer.ffn.down_proj, new_in_features=new_ffn_dim, new_out_features=new_embed_dim, ) # Norm new_layer.norm = expand_rmsnorm(old_layer.norm, new_embed_dim, eps=norm_eps) # adaLN_modulation = Sequential(SiLU, Linear(cond, 3*embed)) new_layer.adaLN_modulation[1] = expand_linear_zero_pad( old_layer.adaLN_modulation[1], new_in_features=new_cond_dim, new_out_features=3 * new_embed_dim, ) return new_layer @torch.no_grad() def expand_final_layer( old_final: nn.Module, new_hidden: int, new_cond: int, output_size: int, norm_eps: float, ) -> nn.Module: """ Expand FinalLayer(hidden, output, cond) to the new hidden/cond dims. Structure: norm_final: RMSNorm(hidden) (no affine) linear: Linear(hidden, output_size) -- zero-pad input adaLN_modulation[1]: Linear(cond, 2*hidden) -- zero-pad in+out `output_size` (latent_size) is UNCHANGED. """ from vibevoice.modular.modular_vibevoice_diffusion_head import FinalLayer new_final = FinalLayer( hidden_size=new_hidden, output_size=output_size, cond_size=new_cond, norm_eps=norm_eps, ) new_final = new_final.to( device=old_final.linear.weight.device, dtype=old_final.linear.weight.dtype, ) # norm_final: RMSNorm without affine -- just rebuild (no weights to copy) # The custom RMSNorm class supports elementwise_affine=False -> weight is None # No action needed; the constructor already handled it. # linear: Linear(old_hidden, output) -> Linear(new_hidden, output) # Output dim unchanged, input dim expanded -> zero-pad input columns new_final.linear = expand_linear_zero_pad( old_final.linear, new_in_features=new_hidden, new_out_features=output_size, ) # adaLN_modulation[1]: Linear(cond, 2*hidden) -> Linear(new_cond, 2*new_hidden) new_final.adaLN_modulation[1] = expand_linear_zero_pad( old_final.adaLN_modulation[1], new_in_features=new_cond, new_out_features=2 * new_hidden, ) return new_final @torch.no_grad() def expand_diffusion_head( old_head: nn.Module, new_hidden_size: int, reinit_cond_proj: bool = True, ) -> nn.Module: """ Expand a VibeVoiceDiffusionHead from old hidden_size to new_hidden_size. The latent_size is UNCHANGED (still 64). Components: noisy_images_proj: Linear(latent=64, hidden) -- zero-pad output cond_proj: Linear(hidden, cond=hidden) -- RE-INITIALISE t_embedder: TimestepEmbedder(cond=hidden) -- zero-pad layers (4x HeadLayer): -- zero-pad final_layer: FinalLayer(hidden, latent, cond) -- zero-pad """ from vibevoice.modular.modular_vibevoice_diffusion_head import ( VibeVoiceDiffusionHead, ) from vibevoice.modular.configuration_vibevoice import ( VibeVoiceDiffusionHeadConfig, ) old_hidden = old_head.config.hidden_size latent_size = old_head.config.latent_size head_layers = old_head.config.head_layers head_ffn_ratio = old_head.config.head_ffn_ratio rms_eps = old_head.config.rms_norm_eps old_ffn_dim = int(old_hidden * head_ffn_ratio) new_ffn_dim = int(new_hidden_size * head_ffn_ratio) print(f" [diffusion_head] hidden_size: {old_hidden} -> {new_hidden_size}") print(f" [diffusion_head] ffn_dim: {old_ffn_dim} -> {new_ffn_dim}") print(f" [diffusion_head] latent_size: {latent_size} (unchanged)") print(f" [diffusion_head] cond_proj reinit: {reinit_cond_proj}") # Build new config new_cfg = VibeVoiceDiffusionHeadConfig( hidden_size=new_hidden_size, head_layers=head_layers, head_ffn_ratio=head_ffn_ratio, rms_norm_eps=rms_eps, latent_size=latent_size, speech_vae_dim=old_head.config.speech_vae_dim, prediction_type=old_head.config.prediction_type, diffusion_type=old_head.config.diffusion_type, ddpm_num_steps=old_head.config.ddpm_num_steps, ddpm_num_inference_steps=old_head.config.ddpm_num_inference_steps, ddpm_beta_schedule=old_head.config.ddpm_beta_schedule, ddpm_batch_mul=old_head.config.ddpm_batch_mul, ) # Build new diffusion head (random init, we'll overwrite below) new_head = VibeVoiceDiffusionHead(new_cfg) new_head = new_head.to( device=old_head.noisy_images_proj.weight.device, dtype=old_head.noisy_images_proj.weight.dtype, ) # noisy_images_proj: Linear(latent, old_hidden) -> Linear(latent, new_hidden) new_head.noisy_images_proj = expand_linear_zero_pad( old_head.noisy_images_proj, new_in_features=latent_size, new_out_features=new_hidden_size, ) # cond_proj: Linear(old_hidden, old_hidden) -> Linear(new_hidden, new_hidden) # Re-initialise: the LLM hidden state space has changed fundamentally. if reinit_cond_proj: print(f" [diffusion_head] cond_proj RE-INITIALISED (LLM hidden space changed)") reinit_linear_like_old(new_head.cond_proj, std=0.02) else: new_head.cond_proj = expand_linear_zero_pad( old_head.cond_proj, new_in_features=new_hidden_size, new_out_features=new_hidden_size, ) # t_embedder new_head.t_embedder = expand_timestep_embedder(old_head.t_embedder, new_hidden_size) # layers (ModuleList) print(f" [diffusion_head] expanding {head_layers} HeadLayer modules...") new_layers = nn.ModuleList() for i, old_l in enumerate(old_head.layers): new_l = expand_head_layer( old_l, new_embed_dim=new_hidden_size, new_ffn_dim=new_ffn_dim, new_cond_dim=new_hidden_size, # cond_dim == hidden_size in this model norm_eps=rms_eps, ) new_layers.append(new_l) new_head.layers = new_layers # final_layer new_head.final_layer = expand_final_layer( old_head.final_layer, new_hidden=new_hidden_size, new_cond=new_hidden_size, output_size=latent_size, norm_eps=rms_eps, ) return new_head # ============================================================================ # Section 5: LLM replacement (the core of the surgery) # ============================================================================ def load_qwen35_text_model( repo: str = NEW_LLM_REPO, torch_dtype: torch.dtype = torch.bfloat16, cache_dir: Optional[str] = None, low_cpu_mem_usage: bool = True, ) -> Tuple[nn.Module, Any]: """ Load just the text decoder of Qwen3.5-4B-Base. The HF repo `Qwen/Qwen3.5-4B-Base` is multimodal (`Qwen3_5ForConditionalGeneration`); we want the inner text model (`Qwen3_5TextModel`, model_type='qwen3_5_text') WITHOUT the lm_head, so that it can serve as `self.language_model` inside VibeVoiceModel (which has its own `lm_head`). Returns (text_model, text_config). """ from transformers import AutoConfig, AutoModel from transformers.models.auto import CONFIG_MAPPING print(f"[qwen3.5] Loading full config from {repo}") full_config = AutoConfig.from_pretrained(repo, cache_dir=cache_dir, trust_remote_code=True) # Extract text_config (multimodal repo) or use full config (text-only repo) if hasattr(full_config, "text_config"): text_config_dict = full_config.text_config.to_dict() else: text_config_dict = full_config.to_dict() print(f"[qwen3.5] Text model_type: {text_config_dict.get('model_type')}") print(f"[qwen3.5] Text hidden_size: {text_config_dict.get('hidden_size')}") print(f"[qwen3.5] Text num_hidden_layers: {text_config_dict.get('num_hidden_layers')}") print(f"[qwen3.5] Text vocab_size: {text_config_dict.get('vocab_size')}") # Try to instantiate the text model class directly. text_model_type = text_config_dict.get("model_type", "qwen3_5_text") text_model = None load_error = None # Strategy 1: try AutoModel with the text config registered as a known type try: from transformers.models.auto import MODEL_MAPPING # Build a standalone text config of the right class # The text_config is already a config instance in newer transformers text_config = full_config.text_config if hasattr(full_config, "text_config") else full_config # AutoModel should pick up Qwen3_5TextModel text_model = AutoModel.from_pretrained( repo, config=text_config, torch_dtype=torch_dtype, cache_dir=cache_dir, low_cpu_mem_usage=low_cpu_mem_usage, trust_remote_code=True, ) print(f"[qwen3.5] Loaded via AutoModel.from_pretrained") except Exception as e: load_error = e print(f"[qwen3.5] AutoModel failed: {e}") # Strategy 2: load Qwen3_5ForCausalLM (or Qwen3_5ForConditionalGeneration) # and extract the inner text model if text_model is None: try: from transformers import AutoModelForCausalLM print(f"[qwen3.5] Falling back to AutoModelForCausalLM...") full_model = AutoModelForCausalLM.from_pretrained( repo, torch_dtype=torch_dtype, cache_dir=cache_dir, low_cpu_mem_usage=low_cpu_mem_usage, trust_remote_code=True, ) # The CausalLM typically has .model (the base text model) if hasattr(full_model, "model") and not hasattr(full_model, "text_model"): text_model = full_model.model # Detach so that disposing of full_model doesn't free the weights full_model.lm_head = None elif hasattr(full_model, "text_model"): text_model = full_model.text_model else: # Last resort: take everything except lm_head text_model = full_model print(f"[qwen3.5] Loaded via AutoModelForCausalLM, " f"text_model class = {type(text_model).__name__}") del full_model gc.collect() except Exception as e: raise RuntimeError( f"Could not load Qwen3.5-4B-Base text model. " f"AutoModel error: {load_error}; AutoModelForCausalLM error: {e}" ) # If text_model still wraps a vision component, strip it if hasattr(text_model, "text_model"): text_model = text_model.text_model text_config = ( full_config.text_config if hasattr(full_config, "text_config") else full_config ) return text_model, text_config @torch.no_grad() def replace_llm_in_vibevoice( vibevoice_model: nn.Module, new_text_model: nn.Module, new_text_config: Any, ) -> nn.Module: """ Replace `vibevoice_model.model.language_model` with `new_text_model` and resize `vibevoice_model.lm_head` to the new vocab/hidden sizes. The old LLM and old lm_head are dropped (returned to caller for memory management). """ # Detach old LLM old_llm = vibevoice_model.model.language_model old_lm_head = vibevoice_model.lm_head # Move new text model to the same device/dtype as the rest of the model target_dtype = next(vibevoice_model.parameters()).dtype target_device = next(vibevoice_model.parameters()).device new_text_model = new_text_model.to(device=target_device, dtype=target_dtype) # Wire it in vibevoice_model.model.language_model = new_text_model # Rebuild lm_head new_hidden = new_text_config.hidden_size new_vocab = new_text_config.vocab_size print(f"[replace_llm] New lm_head: Linear({new_hidden}, {new_vocab}, bias=False)") new_lm_head = nn.Linear(new_hidden, new_vocab, bias=False).to( device=target_device, dtype=target_dtype ) # Re-tie weights if config says so tie = getattr(vibevoice_model.config.decoder_config, "tie_word_embeddings", True) if tie: # Get the input embeddings of the new text model if hasattr(new_text_model, "embed_tokens"): embed = new_text_model.embed_tokens else: # Walk attributes to find embeddings embed = None for n, m in new_text_model.named_modules(): if "embed_tokens" in n: embed = m break if embed is None: raise RuntimeError("Could not find embed_tokens in the new text model.") new_lm_head.weight = embed.weight print(f"[replace_llm] Tied lm_head.weight to embed_tokens.weight") else: # Keep the pretrained lm_head weights from Qwen3.5 if available # (We'd need to pass them in; for now leave default-init.) warnings.warn("tie_word_embeddings=False but no pretrained lm_head passed; " "lm_head will be randomly initialised.") vibevoice_model.lm_head = new_lm_head vibevoice_model.vocab_size = new_vocab return vibevoice_model # ============================================================================ # Section 6: Config update # ============================================================================ def build_new_vibevoice_config( old_config: Any, new_text_config: Any, ) -> Any: """ Build a new VibeVoiceConfig where: - decoder_config is replaced with the Qwen3.5 text config - diffusion_head_config.hidden_size is bumped to new_text_config.hidden_size - acoustic_tokenizer_config / semantic_tokenizer_config are UNCHANGED - vocab_size is updated to the new vocab - tie_word_embeddings matches the new LLM's setting """ from vibevoice.modular.configuration_vibevoice import ( VibeVoiceConfig, VibeVoiceDiffusionHeadConfig, ) new_hidden = new_text_config.hidden_size new_vocab = new_text_config.vocab_size # Convert the Qwen3.5 text config to a plain dict so VibeVoiceConfig can # re-instantiate it via its sub_configs logic. VibeVoiceConfig currently # only knows about Qwen2Config as a decoder type, so we have to extend it. text_cfg_dict = new_text_config.to_dict() if hasattr(new_text_config, "to_dict") else dict(new_text_config) # Build new diffusion head config old_diff_cfg = old_config.diffusion_head_config new_diff_cfg = VibeVoiceDiffusionHeadConfig( hidden_size=new_hidden, head_layers=old_diff_cfg.head_layers, head_ffn_ratio=old_diff_cfg.head_ffn_ratio, rms_norm_eps=old_diff_cfg.rms_norm_eps, latent_size=old_diff_cfg.latent_size, speech_vae_dim=old_diff_cfg.speech_vae_dim, prediction_type=old_diff_cfg.prediction_type, diffusion_type=old_diff_cfg.diffusion_type, ddpm_num_steps=old_diff_cfg.ddpm_num_steps, ddpm_num_inference_steps=old_diff_cfg.ddpm_num_inference_steps, ddpm_beta_schedule=old_diff_cfg.ddpm_beta_schedule, ddpm_batch_mul=old_diff_cfg.ddpm_batch_mul, ) # Build the new VibeVoiceConfig. # We bypass the __init__ sub_config dispatch (which is hardcoded to Qwen2Config) # by constructing a minimal VibeVoiceConfig and assigning the configs manually. new_config = VibeVoiceConfig( acoustic_tokenizer_config=old_config.acoustic_tokenizer_config.to_dict() if hasattr(old_config.acoustic_tokenizer_config, "to_dict") else dict(old_config.acoustic_tokenizer_config), semantic_tokenizer_config=old_config.semantic_tokenizer_config.to_dict() if hasattr(old_config.semantic_tokenizer_config, "to_dict") else dict(old_config.semantic_tokenizer_config), decoder_config=None, # we set it manually below diffusion_head_config=new_diff_cfg.to_dict() if hasattr(new_diff_cfg, "to_dict") else dict(new_diff_cfg.__dict__), ) # Replace decoder_config with the actual Qwen3.5 text config object. # VibeVoiceModel.__init__ uses AutoModel.from_config(lm_config), which # works with any registered config class as long as it knows the model_type. new_config.decoder_config = new_text_config # Top-level fields new_config.vocab_size = new_vocab new_config.tie_word_embeddings = bool( getattr(new_text_config, "tie_word_embeddings", True) ) new_config.acoustic_vae_dim = getattr(old_config, "acoustic_vae_dim", ACOUSTIC_VAE_DIM) new_config.semantic_vae_dim = getattr(old_config, "semantic_vae_dim", SEMANTIC_VAE_DIM) new_config.torch_dtype = "bfloat16" new_config._attn_implementation_autoset = False return new_config # ============================================================================ # Section 7: Main surgery orchestrator # ============================================================================ def perform_surgery( old_checkpoint_path: Union[str, Path], vibevoice_repo_dir: Union[str, Path], output_dir: Union[str, Path], new_llm_repo: str = NEW_LLM_REPO, torch_dtype: torch.dtype = torch.bfloat16, reinit_cond_proj: bool = True, hf_cache_dir: Optional[str] = None, skip_llm_download: bool = False, fake_new_llm: bool = False, ) -> SurgeryReport: """ End-to-end surgery: load old VibeVoice, swap LLM, expand connectors and diffusion head, save the result. Args: old_checkpoint_path: path to the original VibeVoice HF directory (containing config.json + *.safetensors). vibevoice_repo_dir: path to the directory *containing* the `vibevoice/` Python package (so we can import it). output_dir: where to save the surgically-modified model. new_llm_repo: HF repo id for the new LLM. Defaults to Qwen3.5-4B-Base. torch_dtype: dtype to use throughout. bf16 by default (T4-friendly). reinit_cond_proj: whether to re-initialise the diffusion head's cond_proj (recommended when swapping LLMs across families). hf_cache_dir: optional HF cache dir for model downloads. skip_llm_download: if True, do not download Qwen3.5 (used for tests that only verify the surgery primitives). fake_new_llm: if True, build a randomly-initialised text model with the right shape (used for tests that don't need the real LLM). Returns: SurgeryReport with details about what was done. """ output_dir = Path(output_dir) output_dir.mkdir(parents=True, exist_ok=True) # 1. Setup imports print("\n[1/8] Setting up VibeVoice imports...") setup_vibevoice_imports(vibevoice_repo_dir) from vibevoice.modular.configuration_vibevoice import VibeVoiceConfig from vibevoice.modular.modeling_vibevoice import VibeVoiceForConditionalGeneration # 2. Load original VibeVoice print(f"\n[2/8] Loading original VibeVoice from {old_checkpoint_path}...") # NOTE: low_cpu_mem_usage=False is required because the DPMSolverMultistepScheduler # inside VibeVoiceModel.__init__ does .to("cpu") on its sigmas, which fails # under the init_empty_weights context manager that low_cpu_mem_usage=True uses. old_model = VibeVoiceForConditionalGeneration.from_pretrained( old_checkpoint_path, dtype=torch_dtype, # transformers 5.x uses 'dtype' (was 'torch_dtype') low_cpu_mem_usage=False, ) old_model.eval() old_config = old_model.config old_total_params = sum(p.numel() for p in old_model.parameters()) print(f" Old model loaded. Total params: {old_total_params:,}") print(f" Old LLM hidden: {old_config.decoder_config.hidden_size}") print(f" Old vocab: {old_config.decoder_config.vocab_size}") # 3. Load Qwen3.5-4B-Base text model if skip_llm_download: print("\n[3/8] Skipping Qwen3.5 download (skip_llm_download=True).") new_text_model = None # Build a minimal text config matching Qwen3.5-4B from transformers.models.qwen3_5 import Qwen3_5TextConfig new_text_config = Qwen3_5TextConfig( hidden_size=NEW_LLM_HIDDEN_SIZE, num_hidden_layers=NEW_LLM_LAYERS, vocab_size=NEW_LLM_VOCAB, intermediate_size=NEW_LLM_INTERMEDIATE, num_attention_heads=NEW_LLM_HEADS, num_key_value_heads=NEW_LLM_KV_HEADS, tie_word_embeddings=True, ) elif fake_new_llm: print("\n[3/8] Building a FAKE Qwen3.5 text model (for testing only).") from transformers.models.qwen3_5 import Qwen3_5TextConfig, Qwen3_5TextModel new_text_config = Qwen3_5TextConfig( hidden_size=NEW_LLM_HIDDEN_SIZE, num_hidden_layers=NEW_LLM_LAYERS, vocab_size=NEW_LLM_VOCAB, intermediate_size=NEW_LLM_INTERMEDIATE, num_attention_heads=NEW_LLM_HEADS, num_key_value_heads=NEW_LLM_KV_HEADS, tie_word_embeddings=True, ) new_text_model = Qwen3_5TextModel(new_text_config).to(torch_dtype) else: print(f"\n[3/8] Loading Qwen3.5-4B-Base text model from {new_llm_repo}...") new_text_model, new_text_config = load_qwen35_text_model( repo=new_llm_repo, torch_dtype=torch_dtype, cache_dir=hf_cache_dir, low_cpu_mem_usage=True, ) print(f" New LLM hidden: {new_text_config.hidden_size}") print(f" New LLM layers: {new_text_config.num_hidden_layers}") print(f" New vocab: {new_text_config.vocab_size}") # 4. Build the new VibeVoiceConfig print("\n[4/8] Building new VibeVoiceConfig...") new_config = build_new_vibevoice_config(old_config, new_text_config) # 5. Build a new VibeVoiceForConditionalGeneration with the new config, # but WITHOUT re-initialising everything. We'll transplant the old # weights module-by-module. print("\n[5/8] Building new VibeVoice skeleton with new config...") # Save current default dtype, set to torch_dtype for the constructor prev_default = torch.get_default_dtype() torch.set_default_dtype(torch_dtype) new_model = VibeVoiceForConditionalGeneration(new_config) torch.set_default_dtype(prev_default) new_model.eval() # 6. Transplant weights print("\n[6/8] Transplanting weights...") expanded_modules: List[str] = [] reinit_modules: List[str] = [] preserved_modules: List[str] = [] # 6a. Acoustic tokenizer - copy unchanged print(" -> Acoustic tokenizer (UNCHANGED)") new_model.model.acoustic_tokenizer.load_state_dict( old_model.model.acoustic_tokenizer.state_dict(), strict=True ) preserved_modules.append("model.acoustic_tokenizer") # 6b. Semantic tokenizer - copy unchanged print(" -> Semantic tokenizer (UNCHANGED)") new_model.model.semantic_tokenizer.load_state_dict( old_model.model.semantic_tokenizer.state_dict(), strict=True ) preserved_modules.append("model.semantic_tokenizer") # 6c. Acoustic connector - width-expand print(" -> Acoustic connector (width-expand)") new_model.model.acoustic_connector = expand_speech_connector( old_model.model.acoustic_connector, new_output_dim=new_text_config.hidden_size, name="acoustic_connector", ).to(dtype=torch_dtype) expanded_modules.append("model.acoustic_connector") # 6d. Semantic connector - width-expand print(" -> Semantic connector (width-expand)") new_model.model.semantic_connector = expand_speech_connector( old_model.model.semantic_connector, new_output_dim=new_text_config.hidden_size, name="semantic_connector", ).to(dtype=torch_dtype) expanded_modules.append("model.semantic_connector") # 6e. speech_scaling_factor / speech_bias_factor buffers - copy as-is new_model.model.speech_scaling_factor.data.copy_( old_model.model.speech_scaling_factor.data ) new_model.model.speech_bias_factor.data.copy_( old_model.model.speech_bias_factor.data ) # 6f. Diffusion head (prediction_head) - width-expand print(" -> Diffusion head (width-expand)") new_model.model.prediction_head = expand_diffusion_head( old_model.model.prediction_head, new_hidden_size=new_text_config.hidden_size, reinit_cond_proj=reinit_cond_proj, ).to(dtype=torch_dtype) expanded_modules.append("model.prediction_head") if reinit_cond_proj: reinit_modules.append("model.prediction_head.cond_proj") # 6g. LLM - replace print(" -> Language model (REPLACE with Qwen3.5)") if new_text_model is None and not skip_llm_download: raise RuntimeError("new_text_model is None but skip_llm_download=False") if new_text_model is not None: new_model = replace_llm_in_vibevoice( new_model, new_text_model, new_text_config ) reinit_modules.append("model.language_model (replaced)") # 6h. lm_head - either tied or rebuilt (replace_llm_in_vibevoice handled it) preserved_modules.append("lm_head (tied with embed_tokens)") # Free memory del old_model gc.collect() new_total_params = sum(p.numel() for p in new_model.parameters()) print(f"\n New total params: {new_total_params:,}") # 7. Save the model print(f"\n[7/8] Saving surgically modified model to {output_dir}...") new_model.save_pretrained( output_dir, max_shard_size="2GB", safe_serialization=True, ) new_config.save_pretrained(output_dir) # 8. Build & save report print("\n[8/8] Building surgery report...") report = SurgeryReport( old_llm_hidden=old_config.decoder_config.hidden_size, new_llm_hidden=new_text_config.hidden_size, old_vocab=old_config.decoder_config.vocab_size, new_vocab=new_text_config.vocab_size, expanded_modules=expanded_modules, reinitialized_modules=reinit_modules, preserved_modules=preserved_modules, total_params_before=old_total_params, total_params_after=new_total_params, output_dir=str(output_dir), ) print(report.summary()) report_path = output_dir / "surgery_report.json" with open(report_path, "w") as f: json.dump({ "old_llm_hidden": report.old_llm_hidden, "new_llm_hidden": report.new_llm_hidden, "old_vocab": report.old_vocab, "new_vocab": report.new_vocab, "expanded_modules": report.expanded_modules, "reinitialized_modules": report.reinitialized_modules, "preserved_modules": report.preserved_modules, "total_params_before": report.total_params_before, "total_params_after": report.total_params_after, "output_dir": report.output_dir, }, f, indent=2) print(f" Report saved to {report_path}") return report # ============================================================================ # Section 8: Verification helpers # ============================================================================ def verify_surgery( model_dir: Union[str, Path], vibevoice_repo_dir: Union[str, Path], torch_dtype: torch.dtype = torch.bfloat16, device: str = "cuda" if torch.cuda.is_available() else "cpu", ) -> Dict[str, Any]: """ Load the surgically-modified model and run a tiny forward pass to verify there are no shape errors. Returns a dict with key diagnostics. """ print(f"\n[verify] Loading surgically modified model from {model_dir}...") setup_vibevoice_imports(vibevoice_repo_dir) from vibevoice.modular.modeling_vibevoice import VibeVoiceForConditionalGeneration model = VibeVoiceForConditionalGeneration.from_pretrained( model_dir, dtype=torch_dtype, # transformers 5.x low_cpu_mem_usage=False, # see perform_surgery for the reason ) model.to(device) model.eval() print(f" Model device: {next(model.parameters()).device}") print(f" Model dtype: {next(model.parameters()).dtype}") print(f" Vocab size: {model.config.decoder_config.vocab_size}") print(f" Hidden size: {model.config.decoder_config.hidden_size}") print(f" Diffusion hidden: {model.config.diffusion_head_config.hidden_size}") # Forward pass with a tiny fake input. # VibeVoice's forward ALWAYS calls self.model.semantic_connector(...) # and self.forward_speech_features(...), so we MUST provide dummy speech # tensors even for a smoke test. See modeling_vibevoice.py:360. # # The speech path requires carefully matched shapes: # - speech_tensors: (batch, n_audio_samples) -- raw audio waveform # - speech_masks: (batch, n_frames) -- 2D bool mask, n_frames # equals what the acoustic tokenizer produces from # n_audio_samples # - acoustic_input_mask: (batch, seq_len) -- n_frames True positions # (so inputs_embeds[mask] matches speech_embeds shape) # If any of these mismatch, the forward fails with a shape error. We # pre-compute n_frames by running the acoustic tokenizer once on the # dummy audio, then build all masks consistently. If pre-compute fails # (e.g. dtype mismatch), we fall back to testing the inner model only. print(" Running a tiny forward pass (with dummy speech tensors)...") batch = 1 seq_len = 8 input_ids = torch.randint( 0, model.config.decoder_config.vocab_size, (batch, seq_len), device=device ) attention_mask = torch.ones_like(input_ids) sem_vae_dim = model.config.semantic_vae_dim speech_semantic_tensors = torch.zeros(batch, seq_len, sem_vae_dim, device=device, dtype=torch_dtype) speech_tensors = torch.zeros(batch, 3200, device=device, dtype=torch_dtype) # Pre-compute n_frames via the acoustic tokenizer. # `forward()` converts speech_tensors to `self.dtype` before encoding, # so we use model.dtype here (the same strategy as test_audio_generation). n_frames = None encode_dtype_candidates: List[torch.dtype] = [] if hasattr(model, "dtype") and model.dtype is not None: encode_dtype_candidates.append(model.dtype) try: tok_dtype = next(model.model.acoustic_tokenizer.parameters()).dtype if tok_dtype not in encode_dtype_candidates: encode_dtype_candidates.append(tok_dtype) except StopIteration: pass for fallback_dtype in (torch.bfloat16, torch.float32): if fallback_dtype not in encode_dtype_candidates: encode_dtype_candidates.append(fallback_dtype) for try_dtype in encode_dtype_candidates: try: with torch.no_grad(): enc_in = speech_tensors.unsqueeze(1).to(dtype=try_dtype) enc_out = model.model.acoustic_tokenizer.encode(enc_in) n_frames = enc_out.mean.shape[1] print(f" Acoustic tokenizer produced {n_frames} frames from " f"{speech_tensors.shape[-1]} samples (dtype={try_dtype})") break except Exception as e: print(f" Pre-compute with dtype={try_dtype} failed: " f"{type(e).__name__}: {e}") full_forward_ok = False if n_frames is not None and n_frames > 0: # Build correctly-shaped speech_masks and acoustic_input_mask. # - speech_masks: 2D (batch, n_frames), all True (select all frames) # - acoustic_input_mask: 2D (batch, seq_len), with n_frames True # positions (capped at seq_len-1 to leave room for at least one # non-speech token) n_to_set = min(n_frames, seq_len - 1) if n_to_set > 0: speech_masks = torch.zeros(batch, n_frames, dtype=torch.bool, device=device) speech_masks[:, :n_to_set] = True acoustic_input_mask = torch.zeros_like(input_ids, dtype=torch.bool) acoustic_input_mask[0, 1:1 + n_to_set] = True acoustic_loss_mask = torch.zeros_like(input_ids, dtype=torch.bool) speeches_loss_input = torch.zeros_like(input_ids, dtype=torch.bool) try: with torch.no_grad(): out = model( input_ids=input_ids, attention_mask=attention_mask, speech_tensors=speech_tensors, speech_masks=speech_masks, speech_semantic_tensors=speech_semantic_tensors, acoustic_input_mask=acoustic_input_mask, acoustic_loss_mask=acoustic_loss_mask, speeches_loss_input=speeches_loss_input, return_dict=True, use_cache=False, ) logits = out.logits assert logits.shape == (batch, seq_len, model.config.decoder_config.vocab_size), ( f"Logits shape mismatch: {logits.shape}" ) print(f" Full forward pass OK. Logits shape: {tuple(logits.shape)}") full_forward_ok = True except Exception as e: print(f" Full forward pass failed (expected for dummy inputs): " f"{type(e).__name__}: {e}") print(f" Falling back to inner model forward pass (no speech processing)...") else: print(f" n_frames={n_frames} but seq_len={seq_len} too small; " f"skipping full forward pass.") else: print(f" Could not pre-compute n_frames; skipping full forward pass.") if not full_forward_ok: # Fallback: test the inner VibeVoiceModel directly (no speech processing) with torch.no_grad(): inner_out = model.model( input_ids=input_ids, attention_mask=attention_mask, return_dict=True, use_cache=False, ) hidden_states = inner_out.last_hidden_state assert hidden_states.shape == (batch, seq_len, model.config.decoder_config.hidden_size), ( f"Hidden states shape mismatch: {hidden_states.shape}" ) # Compute logits via lm_head logits = model.lm_head(hidden_states) assert logits.shape == (batch, seq_len, model.config.decoder_config.vocab_size), ( f"Logits shape mismatch: {logits.shape}" ) print(f" Inner model forward OK. Logits shape: {tuple(logits.shape)}") # Sanity check: diffusion head can be called directly print(" Running diffusion head smoke test...") latent_size = model.config.diffusion_head_config.latent_size new_hidden = model.config.diffusion_head_config.hidden_size noisy = torch.randn(2, latent_size, device=device, dtype=torch_dtype) t = torch.tensor([10, 500], device=device, dtype=torch_dtype) cond = torch.randn(2, new_hidden, device=device, dtype=torch_dtype) with torch.no_grad(): pred = model.model.prediction_head(noisy, t, cond) assert pred.shape == (2, latent_size), f"Diffusion head shape mismatch: {pred.shape}" print(f" Diffusion head output shape: {tuple(pred.shape)} OK") # Sanity check: connectors produce new-hidden-size output print(" Running connector smoke test...") acoustic_in = torch.randn(3, ACOUSTIC_VAE_DIM, device=device, dtype=torch_dtype) acoustic_out = model.model.acoustic_connector(acoustic_in) assert acoustic_out.shape == (3, new_hidden), acoustic_out.shape print(f" Acoustic connector: {ACOUSTIC_VAE_DIM} -> {tuple(acoustic_out.shape)[-1]} OK") semantic_in = torch.randn(3, SEMANTIC_VAE_DIM, device=device, dtype=torch_dtype) semantic_out = model.model.semantic_connector(semantic_in) assert semantic_out.shape == (3, new_hidden), semantic_out.shape print(f" Semantic connector: {SEMANTIC_VAE_DIM} -> {tuple(semantic_out.shape)[-1]} OK") # Sanity check: zero-padded dims of expanded layers are actually zero print(" Verifying zero-padding of expanded layers...") fc1_w = model.model.acoustic_connector.fc1.weight.data # (new_hidden, in_vae) old_hidden = OLD_LLM_HIDDEN_SIZE new_rows = fc1_w[old_hidden:, :] max_abs_new = new_rows.abs().max().item() print(f" Acoustic connector fc1 new-output max |w|: {max_abs_new:.2e} " f"({'OK' if max_abs_new < 1e-8 else 'NOT ZERO'})") return { "logits_shape": list(logits.shape), "diffusion_output_shape": list(pred.shape), "acoustic_connector_out_shape": list(acoustic_out.shape), "semantic_connector_out_shape": list(semantic_out.shape), "acoustic_fc1_new_rows_max_abs": max_abs_new, "vocab_size": model.config.decoder_config.vocab_size, "hidden_size": model.config.decoder_config.hidden_size, "diffusion_hidden_size": new_hidden, } # ============================================================================ # Section 9: Audio generation test # ============================================================================ def extract_audio_array( outputs: Any, ) -> Tuple[Optional["np.ndarray"], Optional[int]]: """ Extract the first valid audio waveform from a VibeVoice generation output as a contiguous, 1-D float32 numpy array suitable for `soundfile.write`. VibeVoice's `generate()` returns a `VibeVoiceGenerationOutput` whose `speech_outputs` field is a `List[Optional[Tensor]]` (see modeling_vibevoice_inference.py:679-693). An entry is: * None -> when that sample never emitted a `speech_diffusion_id` token, so no audio chunks were collected for it. This is the normal case for an un-fine-tuned model that collapses to EOS. * Tensor -> the concatenated 1-D / 2-D waveform for that sample. This helper scans the list and returns the first non-None entry, converted to float32. Returns (None, None) when no sample produced audio. Robustness notes: * Skips None and empty entries (a `[None]` list is truthy, so the naive `if outputs.speech_outputs:` check is NOT enough -- that was the root cause of the original soundfile "dtype object" crash). * Handles torch tensors (CPU or CUDA, any float dtype incl. bfloat16). bfloat16 has no numpy equivalent, so we upcast to float32 first. * Handles raw numpy arrays and python lists/tuples of numbers too. * Flattens to 1-D (soundfile writes mono waveforms). * NaN/Inf are replaced with 0 so a single bad sample can't abort the write. """ import numpy as np speech_outputs = getattr(outputs, "speech_outputs", None) if not speech_outputs: return None, None # Accept a bare tensor/array/list as well (defensive: some callers pass the # raw waveform instead of the full ModelOutput). if not hasattr(outputs, "speech_outputs"): candidates = [outputs] else: candidates = speech_outputs for idx, wav in enumerate(candidates): arr = None if isinstance(wav, torch.Tensor): # bfloat16 has no numpy dtype -> upcast to float32 before .numpy() wav = wav.detach() if wav.dtype != torch.float32 and wav.dtype != torch.float64: wav = wav.float() # .cpu() in case it's on CUDA arr = wav.cpu().numpy() elif isinstance(wav, np.ndarray): # Could be object dtype if someone did np.asarray(None); reject. if wav.dtype == object: continue if wav.dtype != np.float32 and wav.dtype != np.float64: arr = wav.astype(np.float32) else: arr = wav elif isinstance(wav, (list, tuple)): try: arr = np.asarray(wav, dtype=np.float32) except (ValueError, TypeError): continue else: # None, or any other non-array object -> skip continue # Reject 0-d / empty arrays. if arr is None or arr.size == 0: continue # Flatten to 1-D mono waveform, make contiguous, sanitise non-finite. arr = np.ascontiguousarray(arr.reshape(-1), dtype=np.float32) if not np.all(np.isfinite(arr)): arr = np.nan_to_num(arr, nan=0.0, posinf=0.0, neginf=0.0) return arr, idx return None, None def test_audio_generation( model_dir: Union[str, Path], vibevoice_repo_dir: Union[str, Path], text: str = "Hello, this is a test of the surgically modified VibeVoice model.", output_wav_path: Union[str, Path] = "/home/z/my-project/download/test_audio.wav", torch_dtype: torch.dtype = torch.bfloat16, device: str = "cuda" if torch.cuda.is_available() else "cpu", max_new_tokens: int = 200, ) -> Dict[str, Any]: """ Load the inference variant of the surgically modified model and try to generate audio from text. Because the surgically-modified model has not yet been fine-tuned on speech data, the audio will be garbled -- this is purely a smoke test that the generation pipeline runs end-to-end. The function tries multiple import strategies because different VibeVoice repo forks ship different inference modules: 1. modeling_vibevoice_inference.VibeVoiceForConditionalGenerationInference (older forks / the user's original zip) 2. modeling_vibevoice_streaming_inference.VibeVoiceStreamingForConditionalGenerationInference (official Microsoft VibeVoice repo) 3. Fallback: modeling_vibevoice.VibeVoiceForConditionalGeneration (base model, no generate() — just a forward-pass smoke test) """ print(f"\n[gen] Loading inference model from {model_dir}...") setup_vibevoice_imports(vibevoice_repo_dir) # --- Try to find a usable inference class --- inference_cls = None inference_type = None # Strategy 1: modeling_vibevoice_inference (older forks) try: from vibevoice.modular.modeling_vibevoice_inference import ( VibeVoiceForConditionalGenerationInference, ) inference_cls = VibeVoiceForConditionalGenerationInference inference_type = "non_streaming" print(f" [import] Using VibeVoiceForConditionalGenerationInference " f"from modeling_vibevoice_inference") except ImportError as e1: print(f" [import] modeling_vibevoice_inference not available: {e1}") # Strategy 2: modeling_vibevoice_streaming_inference (Microsoft repo) if inference_cls is None: try: from vibevoice.modular.modeling_vibevoice_streaming_inference import ( VibeVoiceStreamingForConditionalGenerationInference, ) inference_cls = VibeVoiceStreamingForConditionalGenerationInference inference_type = "streaming" print(f" [import] Using VibeVoiceStreamingForConditionalGenerationInference " f"from modeling_vibevoice_streaming_inference") except ImportError as e2: print(f" [import] modeling_vibevoice_streaming_inference not available: {e2}") # Strategy 3: Fall back to the base model (no generate(), just forward) if inference_cls is None: print(f" [import] No inference class found. Falling back to base model.") from vibevoice.modular.modeling_vibevoice import ( VibeVoiceForConditionalGeneration, ) inference_cls = VibeVoiceForConditionalGeneration inference_type = "base_only" # --- Load the model --- try: model = inference_cls.from_pretrained( model_dir, dtype=torch_dtype, # transformers 5.x low_cpu_mem_usage=False, # see perform_surgery for the reason ) model.to(device) model.eval() print(f" Model loaded ({inference_type} variant).") print(f" Model device: {next(model.parameters()).device}") except Exception as e: print(f" Model loading failed: {type(e).__name__}: {e}") import traceback traceback.print_exc() return {"status": "error", "error": f"Model loading failed: {type(e).__name__}: {e}"} # --- Load tokenizer --- print(" Loading tokenizer from Qwen3.5-4B-Base...") try: from vibevoice.modular.modular_vibevoice_text_tokenizer import ( VibeVoiceTextTokenizerFast, ) tokenizer = VibeVoiceTextTokenizerFast.from_pretrained(NEW_LLM_REPO) print(f" Tokenizer vocab size: {tokenizer.vocab_size}") except Exception as e: print(f" Tokenizer loading failed: {type(e).__name__}: {e}") import traceback traceback.print_exc() return {"status": "error", "error": f"Tokenizer loading failed: {type(e).__name__}: {e}"} # --- Build inputs --- system_prompt = ( " Transform the text provided by various speakers into speech output, " "utilizing the distinct voice of each respective speaker.\n" ) full_text = system_prompt + text inputs = tokenizer(full_text, return_tensors="pt") input_ids = inputs["input_ids"].to(device) # Build a fake audio prompt (3 seconds of silence at 24kHz) print(" Building fake reference audio (3 s of silence)...") ref_audio = torch.zeros(1, 24000 * 3, device=device, dtype=torch.float32) speech_tensors = ref_audio # --- Step 1: Encode ref audio to determine n_frames --- # n_frames = number of frames the acoustic tokenizer produces from the # audio. This is needed to build both speech_masks and speech_input_mask # with the correct shapes. # # CRITICAL: `forward()` in modeling_vibevoice_inference.py:222 converts # `speech_tensors` to `self.dtype` (the model's overall dtype) before # calling `_process_speech_inputs`. We MUST match that exact dtype here, # because the acoustic_tokenizer's Conv1d weights/biases are in # `model.dtype`. Using a different dtype (e.g. float32) triggers # `RuntimeError: Input type (float) and bias type (c10::BFloat16) should # be the same`. # # We try multiple dtype candidates because `low_cpu_mem_usage=False` # loading can leave some submodules in a mixed-dtype state, and # `next(acoustic_tokenizer.parameters()).dtype` is not guaranteed to # match the dtype that the rest of the model expects. print(" Encoding ref audio to determine n_frames...") encode_dtype_candidates: List[torch.dtype] = [] # Primary: model.dtype (what forward() actually uses) if hasattr(model, "dtype") and model.dtype is not None: encode_dtype_candidates.append(model.dtype) # Secondary: dtype of the first acoustic_tokenizer parameter try: tok_dtype = next(model.model.acoustic_tokenizer.parameters()).dtype if tok_dtype not in encode_dtype_candidates: encode_dtype_candidates.append(tok_dtype) except StopIteration: pass # Tertiary: dtype of the connector (downstream consumer) try: conn_dtype = next(model.model.acoustic_connector.parameters()).dtype if conn_dtype not in encode_dtype_candidates: encode_dtype_candidates.append(conn_dtype) except StopIteration: pass # Final fallbacks for fallback_dtype in (torch.bfloat16, torch.float32): if fallback_dtype not in encode_dtype_candidates: encode_dtype_candidates.append(fallback_dtype) print(f" Will try encode dtypes: " f"{[str(d) for d in encode_dtype_candidates]}") n_frames = None last_err: Optional[Exception] = None for try_dtype in encode_dtype_candidates: try: with torch.no_grad(): # acoustic_tokenizer.encode expects (batch, channels, samples) enc_input = speech_tensors.unsqueeze(1).to(dtype=try_dtype) enc_out = model.model.acoustic_tokenizer.encode(enc_input) # enc_out is a VibeVoiceTokenizerEncoderOutput (after our patch) # enc_out.mean has shape (batch, n_frames, vae_dim) n_frames = enc_out.mean.shape[1] print(f" Acoustic tokenizer produced {n_frames} frames from " f"{speech_tensors.shape[-1]} samples (dtype={try_dtype})") last_err = None break except Exception as e: last_err = e print(f" Pre-compute with dtype={try_dtype} failed: " f"{type(e).__name__}: {e}") # --- Fail-fast: do NOT fall back to a (1,1) speech_masks. --- # The previous (1,1) fallback caused IndexError at inference line 161 # because the actual `acoustic_connected` had shape (1, N, hidden) while # the mask selected only 1 frame. We MUST know the real n_frames to # build correctly-shaped speech_masks and speech_input_mask. if n_frames is None or n_frames <= 0: msg = ( f"Could not pre-compute n_frames after trying dtypes " f"{[str(d) for d in encode_dtype_candidates]}. " f"Last error: " f"{type(last_err).__name__ if last_err else 'Unknown'}: {last_err}" ) print(f" ERROR: {msg}") print(f" Aborting generation (the (1,1) fallback mask would cause " f"an IndexError in _process_speech_inputs).") return { "status": "error", "error": msg, "inference_type": inference_type, } # --- Step 2: Build speech_input_mask (shape: batch x seq_len) --- # Number of True values MUST equal n_frames (or be capped at seq_len-1). speech_input_mask = torch.zeros_like(input_ids, dtype=torch.bool) n_to_set = min(n_frames, input_ids.shape[1] - 1) if n_to_set <= 0: msg = ( f"Cannot fit any speech frames into the input sequence " f"(n_frames={n_frames}, seq_len={input_ids.shape[1]}). " f"Need seq_len >= 2." ) print(f" ERROR: {msg}") return { "status": "error", "error": msg, "inference_type": inference_type, } speech_input_mask[0, 1:1 + n_to_set] = True print(f" speech_input_mask: {n_to_set} True positions " f"(capped at seq_len-1={input_ids.shape[1]-1})") # --- Step 3: Build speech_masks (shape: batch x n_frames) --- # In VibeVoice's _process_speech_inputs (line 161): # acoustic_connected = self.model.acoustic_connector(acoustic_features)[speech_masks.cpu()] # - acoustic_connected has shape (batch, n_frames, hidden_size) # - speech_masks is 2D (batch, n_frames) to select frames # - tensor_3d[mask_2d] returns (n_true, hidden_size) # - The result is assigned to inputs_embeds[speech_input_mask] which also # has shape (n_true, hidden_size). # # CRITICAL: The number of True values in speech_masks MUST equal the # number of True values in speech_input_mask, because both produce # tensors of shape (n_true, hidden_size) that get assigned to each other. # So if we cap speech_input_mask at n_to_set, we must also cap speech_masks # to select only n_to_set frames. speech_masks = torch.zeros(1, n_frames, dtype=torch.bool, device=device) speech_masks[0, :n_to_set] = True print(f" speech_masks: {n_to_set} True out of {n_frames} frames") print(f" speech_masks shape: {tuple(speech_masks.shape)} " f"(2D: batch x n_frames)") print(f" Input ids shape: {tuple(input_ids.shape)}") # --- If we only have the base model (no generate()), do a forward-pass test --- if inference_type == "base_only": print(f" Running forward-pass smoke test (base model has no generate())...") try: with torch.no_grad(): out = model( input_ids=input_ids, attention_mask=torch.ones_like(input_ids), speech_tensors=speech_tensors, speech_masks=speech_masks, speech_semantic_tensors=torch.zeros( 1, input_ids.shape[1], SEMANTIC_VAE_DIM, device=device, dtype=torch_dtype, ), acoustic_input_mask=speech_input_mask, acoustic_loss_mask=torch.zeros_like(input_ids, dtype=torch.bool), speeches_loss_input=torch.zeros_like(input_ids, dtype=torch.bool), return_dict=True, use_cache=False, ) print(f" Forward pass OK. Logits shape: {tuple(out.logits.shape)}") return { "status": "forward_only", "logits_shape": list(out.logits.shape), "note": "Base model has no generate() method; ran forward-pass only.", } except Exception as e: print(f" Forward pass failed: {type(e).__name__}: {e}") import traceback traceback.print_exc() return {"status": "error", "error": f"Forward pass failed: {type(e).__name__}: {e}"} # --- Full generation (for non-streaming and streaming inference classes) --- print(f" Generating (max_new_tokens={max_new_tokens}, {inference_type} mode)...") try: with torch.no_grad(): # The generate() signature differs between streaming and non-streaming. # Both accept input_ids, attention_mask, speech_tensors, speech_masks, # speech_input_mask, max_new_tokens, tokenizer. We pass them as kwargs # and let the model handle the rest. gen_kwargs = dict( input_ids=input_ids, attention_mask=torch.ones_like(input_ids), speech_tensors=speech_tensors, speech_masks=speech_masks, speech_input_mask=speech_input_mask, max_new_tokens=max_new_tokens, do_sample=False, return_speech=True, tokenizer=tokenizer, ) outputs = model.generate(**gen_kwargs) print(f" Generation finished.") # Extract the first valid audio waveform from the generation output. # `speech_outputs` is a List[Optional[Tensor]]: each entry is a 1-D/2-D # waveform tensor for one batch sample, or None when that sample never # emitted a speech_diffusion_id token (very common for an un-fine-tuned # model that collapses to EOS early). A previous version of this code # only checked whether the LIST was truthy (`[None]` is truthy!), then # blindly did `np.asarray(None)` which yields a dtype='object' array # that soundfile rejects with: # ValueError: dtype must be one of ['float32','float64','int16', # 'int32'] and not 'object' wav, audio_idx = extract_audio_array(outputs) if wav is None: print(" No speech outputs were generated (expected for an " "un-fine-tuned model).") return { "status": "no_audio", "sequence_len": int(outputs.sequences.shape[-1]) if hasattr(outputs, "sequences") else 0, "inference_type": inference_type, } # Write to WAV. wav is guaranteed float32 here (see extract_audio_array), # which is one of soundfile's supported dtypes. import soundfile as sf out_path = Path(output_wav_path) out_path.parent.mkdir(parents=True, exist_ok=True) sf.write(str(out_path), wav, 24000) print(f" Audio written to {out_path} ({len(wav)} samples, " f"from batch index {audio_idx})") return { "status": "ok", "wav_path": str(out_path), "num_samples": int(len(wav)), "sequence_len": int(outputs.sequences.shape[-1]) if hasattr(outputs, "sequences") else 0, "inference_type": inference_type, } except Exception as e: print(f" Generation failed: {type(e).__name__}: {e}") import traceback traceback.print_exc() return {"status": "error", "error": f"{type(e).__name__}: {e}", "inference_type": inference_type} # ============================================================================ # Section 10: CLI entry point # ============================================================================ if __name__ == "__main__": import argparse p = argparse.ArgumentParser(description="VibeVoice LLM Surgery CLI") sub = p.add_subparsers(dest="cmd", required=True) sp = sub.add_parser("surgery", help="Run the full surgery") sp.add_argument("--old-checkpoint", required=True, help="Path to the original VibeVoice HF checkpoint directory") sp.add_argument("--vibevoice-repo", required=True, help="Path to the directory containing the vibevoice/ Python package") sp.add_argument("--output-dir", required=True, help="Where to save the surgically modified model") sp.add_argument("--new-llm-repo", default=NEW_LLM_REPO) sp.add_argument("--hf-cache-dir", default=None) sp.add_argument("--keep-cond-proj", action="store_true", help="Do NOT re-init the diffusion head's cond_proj (default: re-init)") sp.add_argument("--fake-new-llm", action="store_true", help="Use a randomly-initialised fake Qwen3.5 (for tests)") vp = sub.add_parser("verify", help="Verify a surgically modified model") vp.add_argument("--model-dir", required=True) vp.add_argument("--vibevoice-repo", required=True) gp = sub.add_parser("generate", help="Test audio generation") gp.add_argument("--model-dir", required=True) gp.add_argument("--vibevoice-repo", required=True) gp.add_argument("--text", default="Hello, this is a test.") gp.add_argument("--output-wav", default="/home/z/my-project/download/test_audio.wav") args = p.parse_args() if args.cmd == "surgery": perform_surgery( old_checkpoint_path=args.old_checkpoint, vibevoice_repo_dir=args.vibevoice_repo, output_dir=args.output_dir, new_llm_repo=args.new_llm_repo, hf_cache_dir=args.hf_cache_dir, reinit_cond_proj=not args.keep_cond_proj, fake_new_llm=args.fake_new_llm, ) elif args.cmd == "verify": verify_surgery( model_dir=args.model_dir, vibevoice_repo_dir=args.vibevoice_repo, ) elif args.cmd == "generate": test_audio_generation( model_dir=args.model_dir, vibevoice_repo_dir=args.vibevoice_repo, text=args.text, output_wav_path=args.output_wav, )