Upload 46 files

VibeVoice-tpu/diff_head_layers.txt

@@ -0,0 +1,26 @@
+[0] noisy_images_proj.weight (shape: (3584, 64), trainable: True)
+[1] cond_proj.weight (shape: (3584, 3584), trainable: True)
+[2] t_embedder.mlp.0.weight (shape: (3584, 256), trainable: True)
+[3] t_embedder.mlp.2.weight (shape: (3584, 3584), trainable: True)
+[4] layers.0.ffn.gate_proj.weight (shape: (10752, 3584), trainable: True)
+[5] layers.0.ffn.up_proj.weight (shape: (10752, 3584), trainable: True)
+[6] layers.0.ffn.down_proj.weight (shape: (3584, 10752), trainable: True)
+[7] layers.0.norm.weight (shape: (3584,), trainable: True)
+[8] layers.0.adaLN_modulation.1.weight (shape: (10752, 3584), trainable: True)
+[9] layers.1.ffn.gate_proj.weight (shape: (10752, 3584), trainable: True)
+[10] layers.1.ffn.up_proj.weight (shape: (10752, 3584), trainable: True)
+[11] layers.1.ffn.down_proj.weight (shape: (3584, 10752), trainable: True)
+[12] layers.1.norm.weight (shape: (3584,), trainable: True)
+[13] layers.1.adaLN_modulation.1.weight (shape: (10752, 3584), trainable: True)
+[14] layers.2.ffn.gate_proj.weight (shape: (10752, 3584), trainable: True)
+[15] layers.2.ffn.up_proj.weight (shape: (10752, 3584), trainable: True)
+[16] layers.2.ffn.down_proj.weight (shape: (3584, 10752), trainable: True)
+[17] layers.2.norm.weight (shape: (3584,), trainable: True)
+[18] layers.2.adaLN_modulation.1.weight (shape: (10752, 3584), trainable: True)
+[19] layers.3.ffn.gate_proj.weight (shape: (10752, 3584), trainable: True)
+[20] layers.3.ffn.up_proj.weight (shape: (10752, 3584), trainable: True)
+[21] layers.3.ffn.down_proj.weight (shape: (3584, 10752), trainable: True)
+[22] layers.3.norm.weight (shape: (3584,), trainable: True)
+[23] layers.3.adaLN_modulation.1.weight (shape: (10752, 3584), trainable: True)
+[24] final_layer.linear.weight (shape: (64, 3584), trainable: True)
+[25] final_layer.adaLN_modulation.1.weight (shape: (7168, 3584), trainable: True)

VibeVoice-tpu/pyproject.toml

@@ -0,0 +1,35 @@
+[project]
+name = "vibevoice-finetuning"
+version = "0.1.0"
+description = "Open Source finetuning code for VibeVoice"
+readme = "README.md"
+requires-python = ">=3.8"
+license = {file = "LICENSE"}
+authors = [
+    {name = "jpgallegoarvpb", email = "juanpablo.gallego@voicepowered.ai"}
+]
+dependencies = [
+    "numpy~=1.26.0",
+    "resampy==0.4.3",
+    "librosa==0.11.0",
+    "s3tokenizer",
+    "torch",
+    "torchaudio",
+    "transformers",
+    "datasets>=2.18.0",
+    "diffusers==0.29.0",
+    "resemble-perth==1.0.1",
+    "omegaconf==2.3.0",
+    "conformer==0.3.2",
+    "safetensors==0.5.3",
+    "peft>=0.11.0",
+    "tensorboard>=2.12",
+    "wandb"
+]
+
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools.packages.find]
+where = ["src"]

VibeVoice-tpu/src/TPU_SETUP.md

@@ -0,0 +1,310 @@
+# VibeVoice Fine-Tuning on TPU v5e-8 — Setup Guide
+
+## Overview
+
+This guide explains how to set up and run VibeVoice fine-tuning on Google Cloud TPU v5e-8.
+The training code uses PyTorch/XLA with bfloat16 precision and a custom training loop.
+
+## Prerequisites
+
+- Google Cloud account with TPU v5e access
+- A preprocessed dataset directory containing `.pt` files
+- A VibeVoice model directory (optionally with surgery module)
+
+## 1. Create a TPU v5e-8 VM
+
+```bash
+# Set your project
+export PROJECT_ID=your-project-id
+export ZONE=us-central1-b  # TPU v5e available zones
+export VM_NAME=vibevoice-tpu
+
+# Create a Cloud TPU v5e-8 VM
+gcloud compute tpus tpu-vm create $VM_NAME \
+  --zone=$ZONE \
+  --accelerator-type=v5e-8 \
+  --version=tpu-ubuntu2204-base \
+  --project=$PROJECT_ID
+```
+
+## 2. SSH into the TPU VM
+
+```bash
+gcloud compute tpus tpu-vm ssh $VM_NAME --zone=$ZONE --project=$PROJECT_ID
+```
+
+## 3. Install Dependencies
+
+```bash
+# Update system
+sudo apt-get update && sudo apt-get upgrade -y
+
+# Install Python 3.10+ if needed
+sudo apt-get install -y python3.10 python3.10-venv python3-pip
+
+# Create virtual environment
+python3 -m venv ~/vibevoice-env
+source ~/vibevoice-env/bin/activate
+
+# Install PyTorch/XLA (CRITICAL: must match TPU version)
+pip install torch~=2.5.0
+pip install torch_xla[tpu]~=2.5.0 -f https://storage.googleapis.com/libtpu-releases/index.html
+
+# Install transformers and PEFT
+pip install transformers>=4.45.0
+pip install peft>=0.7.0
+pip install datasets
+pip install accelerate
+pip install sentencepiece
+pip install protobuf
+
+# Install additional dependencies
+pip install numpy
+pip install tqdm
+pip install librosa  # For audio loading (optional with preprocessed data)
+
+# Verify TPU is available
+python3 -c "
+import torch_xla.core.xla_model as xm
+device = xm.xla_device()
+print(f'TPU device: {device}')
+print(f'World size: {xm.xrt_world_size()}')
+print('✅ TPU is available!')
+"
+```
+
+## 4. Transfer Data and Model
+
+### Option A: GCS Bucket (Recommended)
+
+```bash
+# Upload your model and data to GCS
+gsutil -m cp -r /path/to/surgery_model gs://your-bucket/models/vibevoice_surgery/
+gsutil -m cp -r /path/to/preprocessed_data gs://your-bucket/data/preprocessed/
+
+# Data can be accessed directly from GCS in the training script
+# or download to local disk first:
+mkdir -p ~/data ~/models
+gsutil -m cp -r gs://your-bucket/data/preprocessed/* ~/data/
+gsutil -m cp -r gs://your-bucket/models/vibevoice_surgery/* ~/models/
+```
+
+### Option B: Direct Transfer
+
+```bash
+# From your local machine, transfer files to the TPU VM
+gcloud compute tpus tpu-vm scp \
+  /path/to/preprocessed_data $VM_NAME:~/data/ \
+  --zone=$ZONE --project=$PROJECT_ID --recurse
+
+gcloud compute tpus tpu-vm scp \
+  /path/to/surgery_model $VM_NAME:~/models/vibevoice_surgery/ \
+  --zone=$ZONE --project=$PROJECT_ID --recurse
+```
+
+## 5. Transfer Training Code
+
+```bash
+# Transfer the training scripts
+gcloud compute tpus tpu-vm scp \
+  /path/to/VibeVoice/src/finetune_vibevoice_tpu.py $VM_NAME:~/finetune_vibevoice_tpu.py \
+  --zone=$ZONE --project=$PROJECT_ID
+
+gcloud compute tpus tpu-vm scp \
+  /path/to/VibeVoice/src/tpu_config.py $VM_NAME:~/tpu_config.py \
+  --zone=$ZONE --project=$PROJECT_ID
+
+# Transfer the vibevoice package
+gcloud compute tpus tpu-vm scp \
+  /path/to/VibeVoice/src/vibevoice $VM_NAME:~/vibevoice/ \
+  --zone=$ZONE --project=$PROJECT_ID --recurse
+
+# Transfer surgery colab (if using surgery model)
+gcloud compute tpus tpu-vm scp \
+  /path/to/VibeVoice/src/vibevoice_surgery_colab.py $VM_NAME:~/vibevoice_surgery_colab.py \
+  --zone=$ZONE --project=$PROJECT_ID
+```
+
+## 6. Run Training
+
+### Basic Usage
+
+```bash
+cd ~
+source ~/vibevoice-env/bin/activate
+
+python3 finetune_vibevoice_tpu.py \
+  --model_name_or_path ~/models/vibevoice_surgery \
+  --preprocessed_dir ~/data \
+  --output_dir ~/output_tpu \
+  --max_steps 5000 \
+  --learning_rate 2e-5 \
+  --gradient_accumulation_steps 8 \
+  --logging_steps 10 \
+  --save_steps 500
+```
+
+### Full Configuration
+
+```bash
+python3 finetune_vibevoice_tpu.py \
+  --model_name_or_path ~/models/vibevoice_surgery \
+  --preprocessed_dir ~/data \
+  --output_dir ~/output_tpu \
+  --max_steps 5000 \
+  --num_train_epochs 3 \
+  --learning_rate 2e-5 \
+  --lr_scheduler_type cosine \
+  --warmup_steps 100 \
+  --per_device_train_batch_size 1 \
+  --gradient_accumulation_steps 8 \
+  --max_grad_norm 1.0 \
+  --gradient_checkpointing \
+  --ce_loss_weight 1.0 \
+  --diffusion_loss_weight 1.0 \
+  --ddpm_batch_mul 1 \
+  --lora_r 8 \
+  --lora_alpha 32 \
+  --lora_dropout 0.05 \
+  --lora_target_modules "q_proj,k_proj,v_proj,o_proj,gate_proj,up_proj,down_proj" \
+  --train_connectors \
+  --train_surgery_module \
+  --no_freeze_llm \
+  --freeze_diffusion_head \
+  --freeze_lm_head \
+  --ema_decay 0.999 \
+  --logging_steps 10 \
+  --eval_steps 500 \
+  --save_steps 500 \
+  --save_total_limit 3 \
+  --eval_split_size 0.05 \
+  --seed 42
+```
+
+### Resume from Checkpoint
+
+```bash
+python3 finetune_vibevoice_tpu.py \
+  --model_name_or_path ~/models/vibevoice_surgery \
+  --preprocessed_dir ~/data \
+  --output_dir ~/output_tpu \
+  --resume_from_checkpoint ~/output_tpu/checkpoint-2000 \
+  --max_steps 5000
+```
+
+## 7. Monitor Training
+
+```bash
+# View training logs in real-time
+tail -f ~/output_tpu/training.log
+
+# Check TPU utilization
+pip install cloud-tpu-diagnostics
+python3 -c "
+import torch_xla.core.xla_model as xm
+print(f'Device: {xm.xla_device()}')
+print(f'Ordinal: {xm.get_ordinal()}')
+print(f'World size: {xm.xrt_world_size()}')
+"
+```
+
+## 8. Retrieve Results
+
+```bash
+# Copy output back to local machine
+gcloud compute tpus tpu-vm scp \
+  $VM_NAME:~/output_tpu/ /local/path/to/output/ \
+  --zone=$ZONE --project=$PROJECT_ID --recurse
+
+# Or upload to GCS
+gsutil -m cp -r ~/output_tpu gs://your-bucket/outputs/vibevoice_tpu/
+```
+
+## Key Differences from GPU Training
+
+| Aspect | GPU (T4/A100) | TPU v5e-8 |
+|--------|---------------|-----------|
+| Framework | PyTorch + CUDA | PyTorch/XLA |
+| Precision | fp16 / bf16 | bf16 (native) |
+| Training Loop | HF Trainer | Custom loop |
+| Data Loading | DataLoader | MpDeviceLoader |
+| Sync | NCCL all-reduce | xm.optimizer_step() |
+| Graph | Dynamic | XLA compiled (static) |
+| Memory | 16-80 GB/chip | 16 GB/chip × 8 |
+| Batch Sync | Automatic | xm.mark_step() |
+
+## Memory Budget (per TPU chip)
+
+| Component | bf16 Size |
+|-----------|-----------|
+| LLM (Qwen3-4B) | ~8 GB |
+| Diffusion Head | ~2 GB |
+| Tokenizers | ~1 GB |
+| LM Head | ~0.3 GB |
+| **Model Total** | **~12 GB** |
+| Gradients | ~0.5 GB |
+| Optimizer | ~1 GB |
+| Activations | ~2 GB |
+| **Total** | **~15.5 GB** |
+| **Available** | **16 GB** |
+
+## Troubleshooting
+
+### XLA Compilation Errors
+```bash
+# Clear XLA cache
+rm -rf /tmp/xla_cache
+
+# Set environment variables
+export XLA_USE_BF16=1
+export PJRT_DEVICE=TPU
+```
+
+### Out of Memory
+```bash
+# Reduce per-device batch size
+--per_device_train_batch_size 1
+
+# Increase gradient accumulation (keeps effective batch)
+--gradient_accumulation_steps 16
+
+# Enable gradient checkpointing
+--gradient_checkpointing
+
+# Freeze more components
+--freeze_diffusion_head
+--lora_wrap_diffusion_head
+```
+
+### Slow First Step
+The first training step is always slow on TPU due to XLA compilation.
+Subsequent steps will be significantly faster. This is normal behavior.
+
+### Process Hangs
+```bash
+# Check TPU health
+python3 -c "
+import torch_xla.core.xla_model as xm
+device = xm.xla_device()
+t = xm.send_cpu_data_to_device([1,2,3], device)
+print('TPU communication OK')
+"
+```
+
+## Performance Tips
+
+1. **Prefetch Data**: Ensure data is on local SSD, not GCS streaming
+2. **Batch Size**: Use batch_size=1 per chip with gradient_accumulation=8
+3. **Gradient Checkpointing**: Always enable for 16GB chips
+4. **XLA Cache**: Set `XLA_PERSISTENT_CACHE_PATH` for faster compilation on restarts
+5. **Data Format**: Preprocessed `.pt` files are fastest (no CPU preprocessing)
+6. **EMA**: EMA runs on CPU to save TPU memory (small overhead per step)
+
+## Effective Batch Size Calculation
+
+```
+effective_batch = per_device_batch × num_chips × gradient_accumulation
+                = 1 × 8 × 8 = 64
+```
+
+Adjust `gradient_accumulation_steps` to reach your target batch size.

VibeVoice-tpu/src/data_vibevoice.py

@@ -0,0 +1,446 @@
+import math
+from dataclasses import dataclass
+from typing import Any, Dict, List, Optional, Sequence, Tuple, Union
+
+import numpy as np
+import torch
+import warnings
+import random
+
+try:
+    import librosa  # type: ignore
+except Exception:  # pragma: no cover
+    librosa = None  # Fallback: user must install librosa when using local audio paths
+
+try:
+    import resampy  # type: ignore
+except Exception:  # pragma: no cover
+    resampy = None
+
+
+def _resample_if_needed(wav: np.ndarray, orig_sr: int, target_sr: int) -> np.ndarray:
+    if orig_sr == target_sr:
+        return wav.astype(np.float32, copy=False)
+    if resampy is not None:
+        return resampy.resample(wav.astype(np.float32), orig_sr, target_sr)
+    if librosa is not None:
+        return librosa.resample(y=wav.astype(np.float32), orig_sr=orig_sr, target_sr=target_sr)
+    warnings.warn(
+        "No resampler available; treating audio as target_sr without resampling. Install resampy or librosa.",
+        RuntimeWarning,
+    )
+    return wav.astype(np.float32, copy=False)
+
+
+# Lightweight HF-style dataset wrapper (optional). Trainer can also pass raw HF datasets directly.
+class VibeVoiceDataset:
+    def __init__(
+        self,
+        dataset: Any,
+        text_column: str = "text",
+        audio_column: str = "audio",
+        voice_prompts_column: Optional[str] = "voice_prompts",
+    ) -> None:
+        self.dataset = dataset
+        self.text_column = text_column
+        self.audio_column = audio_column
+        self.voice_prompts_column = voice_prompts_column
+
+    def __len__(self) -> int:
+        return len(self.dataset)
+
+    def __getitem__(self, idx: int) -> Dict[str, Any]:
+        item = self.dataset[idx]
+        data: Dict[str, Any] = {}
+        data["text"] = item[self.text_column]
+        data["audio"] = item[self.audio_column]
+
+        user_provided_prompt = None
+        if self.voice_prompts_column and self.voice_prompts_column in item:
+            user_provided_prompt = item[self.voice_prompts_column]
+
+        if user_provided_prompt:
+            # A prompt was provided in the dataset, so we use it.
+            if not isinstance(user_provided_prompt, list):
+                data["voice_prompts"] = [user_provided_prompt]
+            else:
+                data["voice_prompts"] = user_provided_prompt
+        else:
+            # FALLBACK: No prompt provided, so we auto-generate one from the target audio.
+            try:
+                target_sr = 24000
+                wav_array = _load_audio_to_24k(item[self.audio_column], target_sr=target_sr)
+                audio_len_seconds = len(wav_array) / target_sr
+
+                min_len_sec = min(5.0, audio_len_seconds / 4.0)
+                max_len_sec = min(15.0, audio_len_seconds / 2.0)
+                
+                if min_len_sec > max_len_sec:
+                    min_len_sec = max_len_sec
+                max_len_sec = min(max_len_sec, audio_len_seconds)
+
+                if max_len_sec > 0.1:
+                    prompt_len_sec = random.uniform(min_len_sec, max_len_sec)
+                    prompt_len_samples = int(prompt_len_sec * target_sr)
+
+                    max_start_sample = len(wav_array) - prompt_len_samples
+                    start_sample = random.randint(0, max_start_sample)
+                    
+                    prompt_crop = wav_array[start_sample : start_sample + prompt_len_samples]
+                    
+                    data["voice_prompts"] = [prompt_crop]
+                else:
+                    data["voice_prompts"] = None
+
+            except Exception as e:
+                warnings.warn(f"Could not create voice prompt for item {idx}: {e}")
+                data["voice_prompts"] = None            
+        return data
+
+
+def _apply_silence_with_crossfade(
+    wav: np.ndarray,
+    *,
+    sample_rate: int,
+    pre_silence_sec: float = 0.25,
+    pre_crossfade_sec: float = 0.25,
+    post_crossfade_sec: float = 0.25,
+    post_silence_sec: float = 0.75,
+) -> np.ndarray:
+    """Pad audio with leading/trailing silence and apply crossfades.
+
+    Structure: [pre_silence][pre_crossfade][audio_body][post_crossfade][post_silence]
+    Crossfades blend the audio with silence linearly to avoid hard edges.
+    """
+
+    wav = np.asarray(wav, dtype=np.float32).reshape(-1)
+
+    start_sil_samples = int(round(pre_silence_sec * sample_rate))
+    end_sil_samples = int(round(post_silence_sec * sample_rate))
+    pre_crossfade_samples = int(round(pre_crossfade_sec * sample_rate))
+    post_crossfade_samples = int(round(post_crossfade_sec * sample_rate))
+
+    total_len = wav.shape[0]
+    if total_len == 0:
+        pieces: List[np.ndarray] = []
+        if start_sil_samples > 0:
+            pieces.append(np.zeros(start_sil_samples, dtype=np.float32))
+        if end_sil_samples > 0:
+            pieces.append(np.zeros(end_sil_samples, dtype=np.float32))
+        return np.concatenate(pieces) if pieces else wav
+
+    start_len = min(pre_crossfade_samples, total_len)
+    remaining_after_start = max(total_len - start_len, 0)
+    end_len = min(post_crossfade_samples, remaining_after_start)
+    middle_end_idx = total_len - end_len
+
+    start_segment = wav[:start_len]
+    middle_segment = wav[start_len:middle_end_idx]
+    end_segment = wav[middle_end_idx:]
+
+    def _linear_fade(num_samples: int, start: float, end: float) -> np.ndarray:
+        if num_samples <= 0:
+            return np.zeros((0,), dtype=np.float32)
+        return np.linspace(start, end, num_samples, endpoint=True, dtype=np.float32)
+
+    start_crossfade = start_segment * _linear_fade(start_len, 0.0, 1.0)
+    end_crossfade = end_segment * _linear_fade(end_segment.shape[0], 1.0, 0.0)
+
+    pieces: List[np.ndarray] = []
+    if start_sil_samples > 0:
+        pieces.append(np.zeros(start_sil_samples, dtype=np.float32))
+    if start_crossfade.size > 0:
+        pieces.append(start_crossfade.astype(np.float32, copy=False))
+    if middle_segment.size > 0:
+        pieces.append(middle_segment.astype(np.float32, copy=False))
+    if end_crossfade.size > 0:
+        pieces.append(end_crossfade.astype(np.float32, copy=False))
+    if end_sil_samples > 0:
+        pieces.append(np.zeros(end_sil_samples, dtype=np.float32))
+
+    return np.concatenate(pieces)
+
+
+def _load_audio_to_24k(
+    audio: Union[str, np.ndarray, torch.Tensor, Dict[str, Any]],
+    *,
+    target_sr: int = 24000,
+    augment_with_silence: bool = False,
+) -> np.ndarray:
+    if isinstance(audio, np.ndarray):
+        wav_out = audio.astype(np.float32)
+    elif isinstance(audio, torch.Tensor):
+        wav_out = audio.detach().cpu().float().numpy()
+    elif isinstance(audio, str):
+        if librosa is None:
+            raise RuntimeError("librosa is required to load audio file paths. Please pip install librosa.")
+        wav, sr = librosa.load(audio, sr=None, mono=True)
+        wav_out = _resample_if_needed(wav, int(sr), target_sr)
+    elif isinstance(audio, dict) and "array" in audio and "sampling_rate" in audio:
+        arr = np.asarray(audio["array"], dtype=np.float32)
+        sr = int(audio["sampling_rate"])
+        wav_out = _resample_if_needed(arr, sr, target_sr)
+    else:
+        raise ValueError(f"Unsupported audio type: {type(audio)}")
+
+    wav_out = np.asarray(wav_out, dtype=np.float32)
+
+    if augment_with_silence:
+        wav_out = _apply_silence_with_crossfade(wav_out, sample_rate=target_sr)
+
+    return wav_out
+
+
+@dataclass
+class VibeVoiceCollator:
+    processor: Any  # VibeVoiceProcessor
+    max_length: Optional[int] = None
+    speech_compress_ratio: int = 3200
+    semantic_vae_dim: int = 128
+    compute_semantics: bool = False
+    debug_checks: bool = False
+
+    text_field: str = "text"
+    audio_field: str = "audio"
+    voice_prompts_field: str = "voice_prompts"
+    voice_prompt_drop_rate: float = 0.0
+
+    def __call__(self, features: Sequence[Dict[str, Any]]) -> Dict[str, Any]:
+        batch_size = len(features)
+
+        sample_input_ids: List[List[int]] = []
+        sample_attention_masks: List[List[int]] = []
+        sample_acoustic_input_masks: List[List[bool]] = []
+        sample_acoustic_loss_masks: List[List[bool]] = []
+
+        all_speech_waveforms: List[np.ndarray] = []
+        all_speech_latent_lengths: List[int] = []
+        per_segment_is_target: List[bool] = []
+
+        for ex in features:
+            text: str = ex.get(self.text_field, "")
+            voice_prompts: Optional[List[Union[str, np.ndarray, torch.Tensor]]] = ex.get(self.voice_prompts_field)
+            target_audio: Union[str, np.ndarray, torch.Tensor, Dict[str, Any]] = ex.get(self.audio_field)
+
+            # Clamp drop rate for safety
+            _drop_rate = self.voice_prompt_drop_rate
+            if _drop_rate < 0.0:
+                _drop_rate = 0.0
+            elif _drop_rate > 1.0:
+                _drop_rate = 1.0
+
+            proc = self.processor(
+                text=[text],
+                voice_samples=[voice_prompts] if voice_prompts is not None and random.random() >= _drop_rate else None,
+                padding=False,
+                truncation=False,
+                max_length=self.max_length,
+                return_tensors="pt",
+            )
+
+            ids = proc["input_ids"][0].tolist()
+            attn = proc.get("attention_mask", torch.ones_like(proc["input_ids"]))[0].tolist()
+            speech_input_mask = proc.get("speech_input_mask")
+            if speech_input_mask is None:
+                speech_input_mask = torch.zeros_like(proc["input_ids"], dtype=torch.bool)
+            speech_input_mask_list = speech_input_mask[0].tolist()
+
+            wav_target = _load_audio_to_24k(target_audio, target_sr=24000, augment_with_silence=True)
+            # Prefer exact frame count from acoustic tokenizer if available; fallback to compress ratio
+            target_latent_len = None
+            try:
+                acoustic_tok = getattr(self.processor, "acoustic_tokenizer", None)
+                if acoustic_tok is not None and hasattr(acoustic_tok, "encode"):
+                    enc_out = acoustic_tok.encode(wav_target)
+                    # Normalize various possible return formats to get time dimension
+                    T = None
+                    try:
+                        # Direct array-like with shape (T, D) or (T,)
+                        if hasattr(enc_out, "shape") and len(getattr(enc_out, "shape", [])) >= 1:
+                            T = int(enc_out.shape[0])
+                        else:
+                            # Nested lists/tuples or ModelOutput-like
+                            cand = enc_out
+                            # Drill down a couple of levels safely
+                            for _ in range(2):
+                                if isinstance(cand, (list, tuple)) and len(cand) > 0:
+                                    cand = cand[0]
+                            if hasattr(cand, "shape") and len(getattr(cand, "shape", [])) >= 1:
+                                T = int(cand.shape[0])
+                    except Exception:
+                        T = None
+                    if T is not None and T > 0:
+                        target_latent_len = T
+            except Exception:
+                target_latent_len = None
+            if target_latent_len is None:
+                target_latent_len = max(1, int(math.ceil(len(wav_target) / float(self.speech_compress_ratio))))
+
+            speech_diff_id = self.processor.tokenizer.speech_diffusion_id
+            target_placeholders = [speech_diff_id] * target_latent_len
+
+            ids_extended = ids + target_placeholders
+            attn_extended = attn + [1] * target_latent_len
+
+            acoustic_input_mask = speech_input_mask_list + [True] * target_latent_len
+            acoustic_loss_mask = ([False] * len(speech_input_mask_list)) + [True] * target_latent_len
+
+            speech_end_id = self.processor.tokenizer.speech_end_id
+            ids_extended.append(speech_end_id)
+            attn_extended.append(1)
+            acoustic_input_mask.append(False)
+            acoustic_loss_mask.append(False)
+
+            # Ensure text decoding sees an explicit end-of-sequence token after speech output.
+            eos_token_id = getattr(self.processor.tokenizer, "eos_id", None)
+            if eos_token_id is None:
+                eos_token_id = getattr(self.processor.tokenizer, "eos_token_id", None)
+            if eos_token_id is not None and eos_token_id >= 0:
+                ids_extended.append(eos_token_id)
+                attn_extended.append(1)
+                acoustic_input_mask.append(False)
+                acoustic_loss_mask.append(False)
+
+            if self.max_length is not None and len(ids_extended) > self.max_length:
+                cut = len(ids_extended) - int(self.max_length)
+                leading_non_acoustic = 0
+                for v in acoustic_input_mask:
+                    if v:
+                        break
+                    leading_non_acoustic += 1
+                if cut > leading_non_acoustic:
+                    raise ValueError(
+                        f"--max_length={self.max_length} would truncate into acoustic tokens. "
+                        f"Needed cut={cut}, but only {leading_non_acoustic} leading non-acoustic tokens available. "
+                        "Increase max_length or shorten text/voice-prompt preamble."
+                    )
+                ids_extended = ids_extended[cut:]
+                attn_extended = attn_extended[cut:]
+                acoustic_input_mask = acoustic_input_mask[cut:]
+                acoustic_loss_mask = acoustic_loss_mask[cut:]
+
+            sample_input_ids.append(ids_extended)
+            sample_attention_masks.append(attn_extended)
+            sample_acoustic_input_masks.append(acoustic_input_mask)
+            sample_acoustic_loss_masks.append(acoustic_loss_mask)
+
+            voice_speeches = []
+            voice_latent_lengths = []
+            if proc.get("speech_tensors") is not None:
+                voice_np = proc["speech_tensors"].cpu().numpy()
+                voice_masks = proc["speech_masks"].cpu().numpy().astype(bool)
+                for seg_idx in range(voice_np.shape[0]):
+                    voice_speeches.append(voice_np[seg_idx])
+                    voice_latent_lengths.append(int(voice_masks[seg_idx].sum()))
+
+            all_speech_waveforms.extend(voice_speeches)
+            all_speech_latent_lengths.extend(voice_latent_lengths)
+            per_segment_is_target.extend([False] * len(voice_speeches))
+
+            all_speech_waveforms.append(wav_target)
+            all_speech_latent_lengths.append(target_latent_len)
+            per_segment_is_target.append(True)
+
+        max_seq_len = max(len(x) for x in sample_input_ids)
+        padded_input_ids = []
+        padded_attention_masks = []
+        padded_acoustic_input_masks = []
+        padded_acoustic_loss_masks = []
+        tok = self.processor.tokenizer
+        pad_token_id = getattr(tok, "pad_token_id", None)
+        if pad_token_id is None or pad_token_id < 0:
+            pad_token_id = getattr(tok, "eos_token_id", None)
+            if pad_token_id is None or pad_token_id < 0:
+                raise ValueError(
+                    "Tokenizer has no pad_token_id or eos_token_id; please set one or pass a valid pad id."
+                )
+        for ids, attn, ain_mask, aloss_mask in zip(
+            sample_input_ids, sample_attention_masks, sample_acoustic_input_masks, sample_acoustic_loss_masks
+        ):
+            pad_len = max_seq_len - len(ids)
+            padded_input_ids.append(ids + [pad_token_id] * pad_len)
+            padded_attention_masks.append(attn + [0] * pad_len)
+            padded_acoustic_input_masks.append(ain_mask + [False] * pad_len)
+            padded_acoustic_loss_masks.append(aloss_mask + [False] * pad_len)
+
+        input_ids_tensor = torch.tensor(padded_input_ids, dtype=torch.long)
+        attention_mask_tensor = torch.tensor(padded_attention_masks, dtype=torch.long)
+        acoustic_input_mask_tensor = torch.tensor(padded_acoustic_input_masks, dtype=torch.bool)
+        acoustic_loss_mask_tensor = torch.tensor(padded_acoustic_loss_masks, dtype=torch.bool)
+
+        if all_speech_waveforms:
+            max_wave_len = max(w.shape[0] for w in all_speech_waveforms)
+            padded_speeches = np.zeros((len(all_speech_waveforms), max_wave_len), dtype=np.float32)
+            for i, w in enumerate(all_speech_waveforms):
+                L = w.shape[0]
+                padded_speeches[i, :L] = w
+
+            max_latent_len = max(all_speech_latent_lengths) if all_speech_latent_lengths else 1
+            speech_masks_np = np.zeros((len(all_speech_waveforms), max_latent_len), dtype=np.bool_)
+            for i, L_lat in enumerate(all_speech_latent_lengths):
+                speech_masks_np[i, :L_lat] = True
+
+            speech_tensors_tensor = torch.tensor(padded_speeches, dtype=torch.float32)
+            speech_masks_tensor = torch.tensor(speech_masks_np, dtype=torch.bool)
+
+            speeches_loss_input_np = np.zeros_like(speech_masks_np, dtype=np.bool_)
+            for i, is_target in enumerate(per_segment_is_target):
+                if is_target:
+                    speeches_loss_input_np[i] = speech_masks_np[i]
+            speeches_loss_input_tensor = torch.tensor(speeches_loss_input_np, dtype=torch.bool)
+
+            # Semantic features
+            if self.compute_semantics and hasattr(self.processor, "semantic_tokenizer") and self.processor.semantic_tokenizer is not None:
+                sem_feats: List[np.ndarray] = []
+                for w in all_speech_waveforms:
+                    try:
+                        # Expect [T, D]  where T ≈ ceil(len(w)/compress_ratio)
+                        sem = self.processor.semantic_tokenizer.encode(w)
+                        sem = np.asarray(sem, dtype=np.float32)
+                    except Exception:
+                        sem = np.zeros((0, self.semantic_vae_dim), dtype=np.float32)
+                    if sem.ndim != 2:
+                        raise RuntimeError(f"Semantic tokenizer returned unexpected shape {sem.shape}. Expect [T, D].")
+                    L = sem.shape[0]
+                    D = sem.shape[1]
+                    if D != self.semantic_vae_dim:
+                        if D < self.semantic_vae_dim:
+                            pad_d = np.zeros((L, self.semantic_vae_dim - D), dtype=np.float32)
+                            sem = np.concatenate([sem, pad_d], axis=1)
+                        else:
+                            sem = sem[:, : self.semantic_vae_dim]
+                    if L < max_latent_len:
+                        pad = np.zeros((max_latent_len - L, self.semantic_vae_dim), dtype=np.float32)
+                        sem = np.concatenate([sem, pad], axis=0)
+                    elif L > max_latent_len:
+                        sem = sem[:max_latent_len]
+                    sem_feats.append(sem.astype(np.float32))
+                speech_semantic_tensors = torch.tensor(np.stack(sem_feats, axis=0), dtype=torch.float32)
+            else:
+                # Semantic tokenizer unavailable while semantics are required for training.
+                # Raise to avoid silently degrading alignment with zeroed features.
+                raise RuntimeError(
+                    "Semantic features are required but could not be computed. "
+                    "Ensure processor.semantic_tokenizer is available or precompute and provide features."
+                )
+        else:
+            speech_tensors_tensor = None
+            speech_masks_tensor = None
+            speeches_loss_input_tensor = None
+            speech_semantic_tensors = None  # No segments in batch
+
+        if self.debug_checks:
+            assert (input_ids_tensor >= 0).all(), "input_ids contains negative indices"
+            if speech_tensors_tensor is not None:
+                assert speech_tensors_tensor.dim() == 2, "Expected speech_tensors 2D [segments, samples]"
+
+        return {
+            "input_ids": input_ids_tensor,
+            "attention_mask": attention_mask_tensor,
+            "speech_tensors": speech_tensors_tensor,
+            "speech_masks": speech_masks_tensor,
+            "speech_semantic_tensors": speech_semantic_tensors,
+            "acoustic_input_mask": acoustic_input_mask_tensor,
+            "acoustic_loss_mask": acoustic_loss_mask_tensor,
+            "speeches_loss_input": speeches_loss_input_tensor,
+        }

VibeVoice-tpu/src/finetune_surgery_colab.ipynb

@@ -0,0 +1,1225 @@
+{
+  "nbformat": 4,
+  "nbformat_minor": 0,
+  "metadata": {
+    "colab": {
+      "provenance": [],
+      "gpuType": "T4"
+    },
+    "kernelspec": {
+      "name": "python3",
+      "display_name": "Python 3"
+    },
+    "language_info": {
+      "name": "python"
+    },
+    "accelerator": "GPU",
+    "gpuClass": "standard"
+  },
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "# 🎙️ VibeVoice Surgery — Fine-Tuning on 2× T4 GPUs\n",
+        "\n",
+        "## Overview\n",
+        "\n",
+        "This notebook fine-tunes the **VibeVoice surgery model** (Qwen3-4B backbone + Surgery Module) on Google Colab with **2× NVIDIA T4 GPUs**.\n",
+        "\n",
+        "### Model Architecture After Surgery\n",
+        "| Component | Dimensions | Notes |\n",
+        "|-----------|-----------|-------|\n",
+        "| Qwen3-4B LLM | 2560-dim, 36 layers | Language model backbone |\n",
+        "| Surgery Module | 2560 → 3584 | Bridging module for diffusion head |\n",
+        "| Diffusion Head | 3584-dim | DDPM-based speech generation |\n",
+        "| Acoustic Connector | 64 → 2560 | Acoustic latent → LLM space |\n",
+        "| Semantic Connector | 128 → 2560 | Semantic latent → LLM space |\n",
+        "\n",
+        "### Training Strategy (Phase-Based)\n",
+        "\n",
+        "**Phase 1** (this notebook): Due to limited VRAM on T4s:\n",
+        "- ❌ **FREEZE**: LLM (Qwen3-4B), Diffusion Head\n",
+        "- ✅ **TRAIN**: Surgery Module, Acoustic Connector, Semantic Connector\n",
+        "\n",
+        "**Phase 2** (optional, after Phase 1 convergence):\n",
+        "- ❌ **FREEZE**: LLM backbone (keep frozen)\n",
+        "- ✅ **TRAIN**: Surgery Module, Connectors, Diffusion Head (LoRA)\n",
+        "\n",
+        "---"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Cell 1: 🔧 Environment Setup & Dependencies"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {},
+      "source": [
+        "#@title 1.1 — Install Dependencies { display-mode: \"form\" }\n",
+        "import subprocess, sys\n",
+        "\n",
+        "def install(package):\n",
+        "    subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", \"-q\", package])\n",
+        "\n",
+        "# Core ML stack\n",
+        "install(\"torch>=2.1.0\")\n",
+        "install(\"transformers>=4.51.0\")  # Qwen3Config support\n",
+        "install(\"peft>=0.11.0\")          # LoRA\n",
+        "install(\"datasets>=2.19.0\")\n",
+        "install(\"accelerate>=0.30.0\")\n",
+        "install(\"safetensors>=0.4.0\")\n",
+        "\n",
+        "# Audio processing\n",
+        "install(\"librosa>=0.10.0\")\n",
+        "install(\"soundfile>=0.12.0\")\n",
+        "install(\"resampy>=0.4.0\")\n",
+        "\n",
+        "# Utilities\n",
+        "install(\"sentencepiece\")\n",
+        "install(\"protobuf\")\n",
+        "install(\"tensorboard\")\n",
+        "install(\"tqdm\")\n",
+        "\n",
+        "print(\"✅ All dependencies installed successfully!\")"
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {},
+      "source": [
+        "#@title 1.2 — Verify GPU Setup { display-mode: \"form\" }\n",
+        "import torch\n",
+        "\n",
+        "print(\"=\" * 60)\n",
+        "print(\"  GPU Configuration\")\n",
+        "print(\"=\" * 60)\n",
+        "print(f\"  PyTorch version:  {torch.__version__}\")\n",
+        "print(f\"  CUDA available:   {torch.cuda.is_available()}\")\n",
+        "print(f\"  GPU count:        {torch.cuda.device_count()}\")\n",
+        "for i in range(torch.cuda.device_count()):\n",
+        "    props = torch.cuda.get_device_properties(i)\n",
+        "    mem_gb = props.total_mem / (1024**3)\n",
+        "    print(f\"  GPU {i}: {props.name} | {mem_gb:.1f} GB VRAM | Compute {props.major}.{props.minor}\")\n",
+        "print(\"=\" * 60)\n",
+        "\n",
+        "assert torch.cuda.device_count() >= 1, \"❌ No GPU found! Go to Runtime > Change runtime type > T4 GPU\"\n",
+        "if torch.cuda.device_count() >= 2:\n",
+        "    print(\"\\n✅ Dual GPU setup detected — DataParallel will be used.\")\n",
+        "else:\n",
+        "    print(\"\\n⚠️  Single GPU detected — training will be slower but functional.\")"
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Cell 2: 📁 Project Setup & Model Paths"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {},
+      "source": [
+        "#@title 2.1 — Configure Paths { display-mode: \"form\" }\n",
+        "import os\n",
+        "\n",
+        "# ══════════════════════════════════════════════════════════\n",
+        "# CONFIGURE THESE PATHS FOR YOUR SETUP\n",
+        "# ══════════════════════════════════════════════════════════\n",
+        "\n",
+        "# Path to the surgery model directory (output of vibevoice_surgery_colab.py)\n",
+        "# On Google Colab, upload to /content/drive/MyDrive/... or /content/...\n",
+        "SURGERY_MODEL_PATH = \"/content/vibevoice_qwen3_surgery\"  #@param {type:\"string\"}\n",
+        "\n",
+        "# Path to your training JSONL file\n",
+        "# Format: {\"text\": \"...\", \"audio\": \"/path/to/audio.wav\"}\n",
+        "TRAIN_JSONL_PATH = \"/content/train.jsonl\"  #@param {type:\"string\"}\n",
+        "\n",
+        "# Optional: Path to validation JSONL\n",
+        "VALIDATION_JSONL_PATH = \"\"  #@param {type:\"string\"}\n",
+        "\n",
+        "# Path to the VibeVoice source code\n",
+        "# You need vibevoice/, vibevoice_surgery_colab.py, data_vibevoice.py\n",
+        "PROJECT_DIR = \"/content/VibeVoice\"  #@param {type:\"string\"}\n",
+        "\n",
+        "# Output directory for trained artifacts\n",
+        "OUTPUT_DIR = \"/content/vibevoice_finetuned\"  #@param {type:\"string\"}\n",
+        "\n",
+        "# ══════════════════════════════════════════════════════════\n",
+        "\n",
+        "# Validation\n",
+        "if not os.path.exists(SURGERY_MODEL_PATH):\n",
+        "    print(f\"⚠️  Surgery model not found at: {SURGERY_MODEL_PATH}\")\n",
+        "    print(f\"   Please upload the surgery model or update the path.\")\n",
+        "    print(f\"   Expected files: config.json, model.safetensors, etc.\")\n",
+        "\n",
+        "if not os.path.exists(TRAIN_JSONL_PATH):\n",
+        "    print(f\"⚠️  Training JSONL not found at: {TRAIN_JSONL_PATH}\")\n",
+        "    print(f\"   Please upload or update the path.\")\n",
+        "\n",
+        "print(f\"\\n📁 Configuration:\")\n",
+        "print(f\"   Surgery Model:  {SURGERY_MODEL_PATH}\")\n",
+        "print(f\"   Train JSONL:    {TRAIN_JSONL_PATH}\")\n",
+        "print(f\"   Validation:     {VALIDATION_JSONL_PATH or '(none)'}\")\n",
+        "print(f\"   Project Dir:    {PROJECT_DIR}\")\n",
+        "print(f\"   Output Dir:     {OUTPUT_DIR}\")"
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {},
+      "source": [
+        "#@title 2.2 — Clone or Link Project { display-mode: \"form\" }\n",
+        "\n",
+        "import os, sys\n",
+        "\n",
+        "# Option A: If project is in a Git repo\n",
+        "GIT_REPO_URL = \"\"  #@param {type:\"string\"}\n",
+        "\n",
+        "if GIT_REPO_URL and not os.path.exists(PROJECT_DIR):\n",
+        "    !git clone {GIT_REPO_URL} {PROJECT_DIR}\n",
+        "    print(f\"✅ Cloned project from {GIT_REPO_URL}\")\n",
+        "elif not os.path.exists(PROJECT_DIR):\n",
+        "    os.makedirs(PROJECT_DIR, exist_ok=True)\n",
+        "    print(f\"⚠️  Created empty project dir at {PROJECT_DIR}\")\n",
+        "    print(f\"   Please upload vibevoice/, vibevoice_surgery_colab.py, data_vibevoice.py, finetune_surgery_t4.py\")\n",
+        "else:\n",
+        "    print(f\"✅ Project dir exists: {PROJECT_DIR}\")\n",
+        "\n",
+        "# Add to Python path\n",
+        "if PROJECT_DIR not in sys.path:\n",
+        "    sys.path.insert(0, PROJECT_DIR)\n",
+        "\n",
+        "# Verify critical files\n",
+        "required_files = [\n",
+        "    \"vibevoice/modular/modeling_vibevoice.py\",\n",
+        "    \"vibevoice/modular/configuration_vibevoice.py\",\n",
+        "    \"vibevoice_surgery_colab.py\",\n",
+        "    \"data_vibevoice.py\",\n",
+        "    \"finetune_surgery_t4.py\",\n",
+        "]\n",
+        "missing = [f for f in required_files if not os.path.exists(os.path.join(PROJECT_DIR, f))]\n",
+        "if missing:\n",
+        "    print(f\"\\n❌ Missing required files:\")\n",
+        "    for f in missing:\n",
+        "        print(f\"   - {f}\")\n",
+        "else:\n",
+        "    print(f\"\\n✅ All required project files found!\")"
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Cell 3: 📊 Dataset Preparation"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {},
+      "source": [
+        "#@title 3.1 — Preview / Prepare Training Data { display-mode: \"form\" }\n",
+        "\n",
+        "import json, os\n",
+        "\n",
+        "def preview_jsonl(path, n=5):\n",
+        "    \"\"\"Preview the first N samples of a JSONL file.\"\"\"\n",
+        "    if not os.path.exists(path):\n",
+        "        print(f\"❌ File not found: {path}\")\n",
+        "        return\n",
+        "    \n",
+        "    print(f\"📄 Previewing: {path}\")\n",
+        "    print(f\"   File size: {os.path.getsize(path) / 1024 / 1024:.2f} MB\")\n",
+        "    \n",
+        "    count = 0\n",
+        "    with open(path, 'r', encoding='utf-8') as f:\n",
+        "        for i, line in enumerate(f):\n",
+        "            if not line.strip():\n",
+        "                continue\n",
+        "            try:\n",
+        "                sample = json.loads(line)\n",
+        "                count += 1\n",
+        "                if i < n:\n",
+        "                    text = sample.get('text', 'N/A')[:100]\n",
+        "                    audio = sample.get('audio', 'N/A')\n",
+        "                    has_vp = 'voice_prompts' in sample\n",
+        "                    print(f\"\\n   Sample {i}:\")\n",
+        "                    print(f\"     Text:  {text}...\" if len(text) > 100 else f\"     Text:  {text}\")\n",
+        "                    print(f\"     Audio: {audio}\")\n",
+        "                    print(f\"     Voice Prompts: {'Yes' if has_vp else 'No (auto-generated)'}\")\n",
+        "            except json.JSONDecodeError:\n",
+        "                print(f\"   ⚠️  Line {i}: Invalid JSON\")\n",
+        "    \n",
+        "    print(f\"\\n   Total samples: {count}\")\n",
+        "\n",
+        "preview_jsonl(TRAIN_JSONL_PATH)\n",
+        "if VALIDATION_JSONL_PATH:\n",
+        "    preview_jsonl(VALIDATION_JSONL_PATH)"
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Cell 4: 🧊 Configure Freezing Strategy\n",
+        "\n",
+        "This is the **most important cell**. You choose exactly which layers to freeze and which to train.\n",
+        "\n",
+        "### Layer Groups\n",
+        "\n",
+        "| Layer Group | Parameters (approx) | Memory Impact | Description |\n",
+        "|-------------|--------------------|--------------:|-------------|\n",
+        "| **LLM (Qwen3-4B)** | ~4B | ~8 GB fp16 | Language model backbone |\n",
+        "| **Diffusion Head** | ~107M | ~214 MB fp16 | DDPM denoiser |\n",
+        "| **Surgery Module** | ~26M | ~52 MB fp16 | 2560→3584 bridge |\n",
+        "| **Acoustic Connector** | ~0.1M | ~0.2 MB fp16 | 64→2560 projection |\n",
+        "| **Semantic Connector** | ~0.3M | ~0.6 MB fp16 | 128→2560 projection |\n",
+        "| **LM Head** | ~388M | ~776 MB fp16 | Tied to embeddings (frozen) |\n",
+        "\n",
+        "### Recommended Phase 1 Strategy (T4 VRAM constrained)\n",
+        "Freeze **LLM + Diffusion Head + LM Head**, train **Surgery Module + Connectors**"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {},
+      "source": [
+        "#@title 4.1 — Layer Freezing Configuration { display-mode: \"form\" }\n",
+        "\n",
+        "# ══════════════════════════════════════════════════════════\n",
+        "# FREEZING STRATEGY — Choose what to freeze/train\n",
+        "# ══════════════════════════════════════════════════════════\n",
+        "\n",
+        "FREEZE_LLM = True    #@param {type:\"boolean\"}\n",
+        "FREEZE_DIFFUSION_HEAD = True   #@param {type:\"boolean\"}\n",
+        "FREEZE_SURGERY_MODULE = False  #@param {type:\"boolean\"}\n",
+        "FREEZE_CONNECTORS = False      #@param {type:\"boolean\"}\n",
+        "FREEZE_LM_HEAD = True          #@param {type:\"boolean\"}\n",
+        "FREEZE_ACOUSTIC_TOKENIZER = True  #@param {type:\"boolean\"}\n",
+        "FREEZE_SEMANTIC_TOKENIZER = True  #@param {type:\"boolean\"}\n",
+        "\n",
+        "# ── LoRA Settings ──\n",
+        "# Only used if LLM is NOT frozen\n",
+        "USE_LORA_ON_LLM = False   #@param {type:\"boolean\"}\n",
+        "LORA_R = 8         #@param {type:\"integer\"}\n",
+        "LORA_ALPHA = 32    #@param {type:\"integer\"}\n",
+        "LORA_DROPOUT = 0.05  #@param {type:\"float\"}\n",
+        "\n",
+        "# If LLM is frozen, force-disable LoRA\n",
+        "if FREEZE_LLM:\n",
+        "    USE_LORA_ON_LLM = False\n",
+        "    LORA_TARGET_MODULES = \"none\"\n",
+        "else:\n",
+        "    LORA_TARGET_MODULES = \"q_proj,k_proj,v_proj,o_proj,gate_proj,up_proj,down_proj\" if USE_LORA_ON_LLM else \"none\"\n",
+        "\n",
+        "# ── Diffusion Head LoRA (optional) ──\n",
+        "LORA_WRAP_DIFFUSION_HEAD = False  #@param {type:\"boolean\"}\n",
+        "TRAIN_DIFFUSION_HEAD = False       #@param {type:\"boolean\"}\n",
+        "\n",
+        "# ── Print Summary ──\n",
+        "print(\"=\" * 60)\n",
+        "print(\"  Freezing Strategy\")\n",
+        "print(\"=\" * 60)\n",
+        "components = [\n",
+        "    (\"LLM (Qwen3-4B)\",        FREEZE_LLM,               \"~4B params\"),\n",
+        "    (\"Diffusion Head\",        FREEZE_DIFFUSION_HEAD,     \"~107M params\"),\n",
+        "    (\"Surgery Module\",        FREEZE_SURGERY_MODULE,     \"~26M params\"),\n",
+        "    (\"Acoustic Connector\",    FREEZE_CONNECTORS,         \"~0.1M params\"),\n",
+        "    (\"Semantic Connector\",    FREEZE_CONNECTORS,         \"~0.3M params\"),\n",
+        "    (\"LM Head\",              FREEZE_LM_HEAD,            \"~388M params\"),\n",
+        "    (\"Acoustic Tokenizer\",   FREEZE_ACOUSTIC_TOKENIZER, \"~30M params\"),\n",
+        "    (\"Semantic Tokenizer\",   FREEZE_SEMANTIC_TOKENIZER, \"~30M params\"),\n",
+        "]\n",
+        "\n",
+        "train_count = 0\n",
+        "for name, frozen, params in components:\n",
+        "    status = \"❌ FREEZE\" if frozen else \"✅ TRAIN\"\n",
+        "    print(f\"  {name:<25s} {status:<12s}  {params}\")\n",
+        "    if not frozen:\n",
+        "        train_count += 1\n",
+        "\n",
+        "print(f\"\\n  LoRA on LLM:             {'✅ Yes (r=' + str(LORA_R) + ')' if USE_LORA_ON_LLM else '❌ No'}\")\n",
+        "print(f\"  LoRA on Diffusion Head:  {'✅ Yes' if LORA_WRAP_DIFFUSION_HEAD else '❌ No'}\")\n",
+        "print(f\"  Full Train Diffusion:    {'✅ Yes' if TRAIN_DIFFUSION_HEAD else '❌ No'}\")\n",
+        "print(f\"\\n  Components to train: {train_count}\")\n",
+        "print(\"=\" * 60)"
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {},
+      "source": [
+        "#@title 4.2 — Advanced: Per-Layer Freezing in Diffusion Head { display-mode: \"form\" }\n",
+        "\n",
+        "# If you want to freeze specific parameter groups within the diffusion head\n",
+        "# (e.g., freeze lower layers, only train upper layers), you can specify\n",
+        "# parameter indices to freeze.\n",
+        "#\n",
+        "# Diffusion Head parameter groups:\n",
+        "#   [0] noisy_images_proj.weight  — input projection (64 → 3584)\n",
+        "#   [1] cond_proj.weight          — condition projection (3584 → 3584)\n",
+        "#   [2] t_embedder.mlp.0.weight   — timestep embedding (256 → 3584)\n",
+        "#   [3] t_embedder.mlp.2.weight   — timestep embedding (3584 → 3584)\n",
+        "#   [4-N] layers.*               — transformer layers (HeadLayer)\n",
+        "#   [final] final_layer.*        — final output layer\n",
+        "\n",
+        "LAYERS_TO_FREEZE_IN_HEAD = \"\"  #@param {type:\"string\"}\n",
+        "# Example: \"0,1\" to freeze noisy_images_proj and cond_proj\n",
+        "# Leave empty to freeze/unfreeze the entire head as a unit\n",
+        "\n",
+        "if LAYERS_TO_FREEZE_IN_HEAD:\n",
+        "    print(f\"Diffusion head params to freeze by index: {LAYERS_TO_FREEZE_IN_HEAD}\")\n",
+        "else:\n",
+        "    print(\"No per-parameter freezing configured for diffusion head.\")"
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Cell 5: 🚀 Training Configuration"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {},
+      "source": [
+        "#@title 5.1 — Hyperparameters { display-mode: \"form\" }\n",
+        "\n",
+        "# ══════════════════════════════════════════════════════════\n",
+        "# TRAINING HYPERPARAMETERS\n",
+        "# ══════════════════════════════════════════════════════════\n",
+        "\n",
+        "NUM_EPOCHS = 3              #@param {type:\"integer\"}\n",
+        "BATCH_SIZE_PER_GPU = 1      #@param {type:\"integer\"}\n",
+        "GRADIENT_ACCUMULATION_STEPS = 8  #@param {type:\"integer\"}\n",
+        "LEARNING_RATE = 2e-5        #@param {type:\"number\"}\n",
+        "WARMUP_RATIO = 0.05         #@param {type:\"number\"}\n",
+        "WEIGHT_DECAY = 0.01         #@param {type:\"number\"}\n",
+        "MAX_GRAD_NORM = 1.0         #@param {type:\"number\"}\n",
+        "MAX_LENGTH = 2048           #@param {type:\"integer\"}\n",
+        "\n",
+        "# Loss weights\n",
+        "CE_LOSS_WEIGHT = 1.0        #@param {type:\"number\"}\n",
+        "DIFFUSION_LOSS_WEIGHT = 1.0  #@param {type:\"number\"}\n",
+        "DDPM_BATCH_MUL = 4          #@param {type:\"integer\"}\n",
+        "\n",
+        "# Data\n",
+        "VOICE_PROMPT_DROP_RATE = 0.0  #@param {type:\"number\"}\n",
+        "EVAL_SPLIT_SIZE = 0.05        #@param {type:\"number\"}\n",
+        "\n",
+        "# Precision\n",
+        "USE_FP16 = True               #@param {type:\"boolean\"}\n",
+        "USE_BF16 = False              #@param {type:\"boolean\"}\n",
+        "\n",
+        "# Memory optimization\n",
+        "GRADIENT_CHECKPOINTING = True  #@param {type:\"boolean\"}\n",
+        "\n",
+        "# Logging\n",
+        "LOGGING_STEPS = 10           #@param {type:\"integer\"}\n",
+        "SAVE_STEPS = 500             #@param {type:\"integer\"}\n",
+        "SAVE_TOTAL_LIMIT = 3         #@param {type:\"integer\"}\n",
+        "EVAL_STEPS = 500             #@param {type:\"integer\"}\n",
+        "\n",
+        "# Seed\n",
+        "SEED = 42                    #@param {type:\"integer\"}\n",
+        "\n",
+        "# Compute effective batch size\n",
+        "num_gpus = max(1, __import__('torch').cuda.device_count())\n",
+        "effective_batch = BATCH_SIZE_PER_GPU * GRADIENT_ACCUMULATION_STEPS * num_gpus\n",
+        "print(f\"\\n📊 Training Configuration:\")\n",
+        "print(f\"   Epochs:           {NUM_EPOCHS}\")\n",
+        "print(f\"   Batch/GPU:        {BATCH_SIZE_PER_GPU}\")\n",
+        "print(f\"   Grad Accum:       {GRADIENT_ACCUMULATION_STEPS}\")\n",
+        "print(f\"   GPUs:             {num_gpus}\")\n",
+        "print(f\"   Effective Batch:  {effective_batch}\")\n",
+        "print(f\"   Learning Rate:    {LEARNING_RATE}\")\n",
+        "print(f\"   Precision:        {'fp16' if USE_FP16 else 'bf16' if USE_BF16 else 'fp32'}\")\n",
+        "print(f\"   Grad Checkpoint:  {GRADIENT_CHECKPOINTING}\")"
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Cell 6: 🏋️ Launch Fine-Tuning"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {},
+      "source": [
+        "#@title 6.1 — Build & Run Training Command { display-mode: \"form\" }\n",
+        "\n",
+        "import os, sys\n",
+        "\n",
+        "# Change to project directory\n",
+        "os.chdir(PROJECT_DIR)\n",
+        "\n",
+        "# Build the training command\n",
+        "cmd = f\"\"\"\n",
+        "python finetune_surgery_t4.py \\\n",
+        "    --model_name_or_path \"{SURGERY_MODEL_PATH}\" \\\n",
+        "    --processor_name_or_path \"{SURGERY_MODEL_PATH}\" \\\n",
+        "    --train_jsonl \"{TRAIN_JSONL_PATH}\" \\\n",
+        "    {f'--validation_jsonl \"{VALIDATION_JSONL_PATH}\"' if VALIDATION_JSONL_PATH else ''} \\\n",
+        "    --output_dir \"{OUTPUT_DIR}\" \\\n",
+        "    --max_length {MAX_LENGTH} \\\n",
+        "    --num_train_epochs {NUM_EPOCHS} \\\n",
+        "    --per_device_train_batch_size {BATCH_SIZE_PER_GPU} \\\n",
+        "    --gradient_accumulation_steps {GRADIENT_ACCUMULATION_STEPS} \\\n",
+        "    --learning_rate {LEARNING_RATE} \\\n",
+        "    --warmup_ratio {WARMUP_RATIO} \\\n",
+        "    --weight_decay {WEIGHT_DECAY} \\\n",
+        "    --max_grad_norm {MAX_GRAD_NORM} \\\n",
+        "    --gradient_clipping \\\n",
+        "    --ddpm_batch_mul {DDPM_BATCH_MUL} \\\n",
+        "    --ce_loss_weight {CE_LOSS_WEIGHT} \\\n",
+        "    --diffusion_loss_weight {DIFFUSION_LOSS_WEIGHT} \\\n",
+        "    --voice_prompt_drop_rate {VOICE_PROMPT_DROP_RATE} \\\n",
+        "    --eval_split_size {EVAL_SPLIT_SIZE} \\\n",
+        "    --do_eval \\\n",
+        "    --logging_steps {LOGGING_STEPS} \\\n",
+        "    --save_steps {SAVE_STEPS} \\\n",
+        "    --save_total_limit {SAVE_TOTAL_LIMIT} \\\n",
+        "    --eval_steps {EVAL_STEPS} \\\n",
+        "    --evaluation_strategy steps \\\n",
+        "    --load_best_model_at_end \\\n",
+        "    --metric_for_best_model eval_loss \\\n",
+        "    --greater_is_better False \\\n",
+        "    --save_strategy steps \\\n",
+        "    --report_to tensorboard \\\n",
+        "    --run_name vibevoice_surgery_finetune \\\n",
+        "    --seed {SEED} \\\n",
+        "    --dataloader_num_workers 2 \\\n",
+        "    --ignore_verifications \\\n",
+        "    --remove_unused_columns False \\\n",
+        "    --dataloader_pin_memory True \\\n",
+        "    --freeze_llm {str(FREEZE_LLM).lower()} \\\n",
+        "    --freeze_diffusion_head {str(FREEZE_DIFFUSION_HEAD).lower()} \\\n",
+        "    --freeze_surgery_module {str(FREEZE_SURGERY_MODULE).lower()} \\\n",
+        "    --freeze_connectors {str(FREEZE_CONNECTORS).lower()} \\\n",
+        "    --freeze_lm_head {str(FREEZE_LM_HEAD).lower()} \\\n",
+        "    --freeze_acoustic_tokenizer {str(FREEZE_ACOUSTIC_TOKENIZER).lower()} \\\n",
+        "    --freeze_semantic_tokenizer {str(FREEZE_SEMANTIC_TOKENIZER).lower()} \\\n",
+        "    --lora_target_modules {LORA_TARGET_MODULES} \\\n",
+        "    --lora_r {LORA_R} \\\n",
+        "    --lora_alpha {LORA_ALPHA} \\\n",
+        "    --lora_dropout {LORA_DROPOUT} \\\n",
+        "    --lora_wrap_diffusion_head {str(LORA_WRAP_DIFFUSION_HEAD).lower()} \\\n",
+        "    --train_diffusion_head {str(TRAIN_DIFFUSION_HEAD).lower()} \\\n",
+        "    --train_connectors {str(not FREEZE_CONNECTORS).lower()} \\\n",
+        "    --train_surgery_module {str(not FREEZE_SURGERY_MODULE).lower()} \\\n",
+        "    {f'--layers_to_freeze \"{LAYERS_TO_FREEZE_IN_HEAD}\"' if LAYERS_TO_FREEZE_IN_HEAD else ''} \\\n",
+        "    {'--fp16' if USE_FP16 else ''} \\\n",
+        "    {'--bf16' if USE_BF16 else ''} \\\n",
+        "    {'--gradient_checkpointing' if GRADIENT_CHECKPOINTING else ''}\n",
+        "\"\"\"\n",
+        "\n",
+        "# Clean up the command (remove extra spaces and empty lines)\n",
+        "import re\n",
+        "cmd = re.sub(r'\\\\\\n\\s*\\\\', r'\\\\', cmd)  # Remove empty continuations\n",
+        "cmd = re.sub(r'\\s+\\\\\\n\\s*$', '', cmd)     # Clean trailing backslash\n",
+        "cmd = cmd.strip()\n",
+        "\n",
+        "print(\"=\" * 60)\n",
+        "print(\"  Training Command\")\n",
+        "print(\"=\" * 60)\n",
+        "print(cmd)\n",
+        "print(\"=\" * 60)\n",
+        "\n",
+        "# ── PRE-TRAINING CHECKS ──\n",
+        "print(\"\\n🔍 Pre-training checks:\")\n",
+        "\n",
+        "errors = []\n",
+        "warnings_list = []\n",
+        "\n",
+        "# Check surgery model exists\n",
+        "if not os.path.exists(SURGERY_MODEL_PATH):\n",
+        "    errors.append(f\"Surgery model not found: {SURGERY_MODEL_PATH}\")\n",
+        "else:\n",
+        "    config_path = os.path.join(SURGERY_MODEL_PATH, \"config.json\")\n",
+        "    if os.path.exists(config_path):\n",
+        "        print(f\"  ✅ Surgery model config found\")\n",
+        "    else:\n",
+        "        errors.append(f\"config.json not found in {SURGERY_MODEL_PATH}\")\n",
+        "\n",
+        "# Check training data\n",
+        "if not os.path.exists(TRAIN_JSONL_PATH):\n",
+        "    errors.append(f\"Training JSONL not found: {TRAIN_JSONL_PATH}\")\n",
+        "else:\n",
+        "    with open(TRAIN_JSONL_PATH, 'r') as f:\n",
+        "        lines = f.readlines()\n",
+        "    print(f\"  ✅ Training data: {len(lines)} samples\")\n",
+        "\n",
+        "# Check GPU memory\n",
+        "if torch.cuda.is_available():\n",
+        "    for i in range(torch.cuda.device_count()):\n",
+        "        mem = torch.cuda.get_device_properties(i).total_mem / 1024**3\n",
+        "        print(f\"  ✅ GPU {i}: {mem:.1f} GB\")\n",
+        "\n",
+        "if errors:\n",
+        "    print(f\"\\n❌ ERRORS (fix before training):\")\n",
+        "    for e in errors:\n",
+        "        print(f\"   - {e}\")\n",
+        "    raise RuntimeError(\"Pre-training checks failed. See errors above.\")\n",
+        "\n",
+        "if warnings_list:\n",
+        "    print(f\"\\n⚠️  Warnings:\")\n",
+        "    for w in warnings_list:\n",
+        "        print(f\"   - {w}\")\n",
+        "\n",
+        "print(\"\\n✅ All checks passed! Starting training...\")\n",
+        "print(\"=\" * 60)"
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {},
+      "source": [
+        "#@title 6.2 — Execute Training { display-mode: \"form\" }\n",
+        "\n",
+        "# Run the training command\n",
+        "import subprocess, os\n",
+        "\n",
+        "os.chdir(PROJECT_DIR)\n",
+        "\n",
+        "print(\"🚀 Starting fine-tuning...\")\n",
+        "print(\"=\" * 60)\n",
+        "print(\"\"\"\n",
+        "NOTE: This will run for the configured number of epochs.\n",
+        "Monitor the output for:\n",
+        "  - ce_loss: Cross-entropy loss on text tokens\n",
+        "  - diffusion_loss: MSE loss on speech generation\n",
+        "  - learning_rate_real: Actual learning rate\n",
+        "\n",
+        "Expected behavior:\n",
+        "  - Phase 1 (frozen LLM+head): losses should decrease steadily\n",
+        "  - Trainable params should show nonzero gradients\n",
+        "  - EMA callback will track prediction head params\n",
+        "\"\"\")\n",
+        "print(\"=\" * 60)\n",
+        "\n",
+        "# Execute\n",
+        "process = subprocess.Popen(\n",
+        "    cmd,\n",
+        "    shell=True,\n",
+        "    stdout=subprocess.PIPE,\n",
+        "    stderr=subprocess.STDOUT,\n",
+        "    universal_newlines=True,\n",
+        "    bufsize=1,\n",
+        ")\n",
+        "\n",
+        "# Stream output\n",
+        "for line in process.stdout:\n",
+        "    print(line, end='')\n",
+        "\n",
+        "process.wait()\n",
+        "exit_code = process.returncode\n",
+        "\n",
+        "print(\"\\n\" + \"=\" * 60)\n",
+        "if exit_code == 0:\n",
+        "    print(\"✅ Training completed successfully!\")\n",
+        "else:\n",
+        "    print(f\"❌ Training failed with exit code: {exit_code}\")\n",
+        "print(\"=\" * 60)"
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Cell 7: 📈 Monitor Training"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {},
+      "source": [
+        "#@title 7.1 — Launch TensorBoard { display-mode: \"form\" }\n",
+        "\n",
+        "%load_ext tensorboard\n",
+        "%tensorboard --logdir {OUTPUT_DIR}"
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {},
+      "source": [
+        "#@title 7.2 — Check Saved Artifacts { display-mode: \"form\" }\n",
+        "\n",
+        "import os, glob\n",
+        "\n",
+        "print(\"=\" * 60)\n",
+        "print(\"  Saved Artifacts\")\n",
+        "print(\"=\" * 60)\n",
+        "\n",
+        "lora_dir = os.path.join(OUTPUT_DIR, \"lora\")\n",
+        "if os.path.exists(lora_dir):\n",
+        "    for root, dirs, files in os.walk(lora_dir):\n",
+        "        level = root.replace(lora_dir, '').count(os.sep)\n",
+        "        indent = '  ' * level\n",
+        "        print(f'{indent}{os.path.basename(root)}/')\n",
+        "        subindent = '  ' * (level + 1)\n",
+        "        for file in sorted(files):\n",
+        "            fpath = os.path.join(root, file)\n",
+        "            size_mb = os.path.getsize(fpath) / 1024 / 1024\n",
+        "            print(f'{subindent}{file} ({size_mb:.2f} MB)')\n",
+        "else:\n",
+        "    print(f\"  ⚠️  No lora/ directory found in {OUTPUT_DIR}\")\n",
+        "\n",
+        "# Check checkpoints\n",
+        "checkpoints = sorted(glob.glob(os.path.join(OUTPUT_DIR, \"checkpoint-*\")))\n",
+        "print(f\"\\n📦 Checkpoints: {len(checkpoints)}\")\n",
+        "for ckpt in checkpoints[-3:]:  # Show last 3\n",
+        "    print(f\"  {os.path.basename(ckpt)}\")\n",
+        "\n",
+        "print(\"=\" * 60)"
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Cell 8: 🔄 Phase 2 — Expand Training (Optional)\n",
+        "\n",
+        "After Phase 1 converges, you can expand training to include more layers."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {},
+      "source": [
+        "#@title 8.1 — Configure Phase 2 { display-mode: \"form\" }\n",
+        "\n",
+        "# ══════════════════════════════════════════════════════════\n",
+        "# PHASE 2: Expand training scope\n",
+        "# ══════════════════════════════════════════════════════════\n",
+        "\n",
+        "RUN_PHASE_2 = False  #@param {type:\"boolean\"}\n",
+        "\n",
+        "# Phase 2 settings — keep LLM frozen, add Diffusion Head\n",
+        "P2_FREEZE_LLM = True\n",
+        "P2_FREEZE_DIFFUSION_HEAD = False  # Unfreeze diffusion head!\n",
+        "P2_FREEZE_SURGERY_MODULE = False\n",
+        "P2_FREEZE_CONNECTORS = False\n",
+        "P2_LORA_WRAP_DIFFUSION_HEAD = True  # Use LoRA on head to save VRAM\n",
+        "P2_LEARNING_RATE = 1e-5  # Lower LR for Phase 2\n",
+        "P2_NUM_EPOCHS = 2\n",
+        "\n",
+        "# Resume from Phase 1 checkpoint\n",
+        "P2_RESUME_FROM = os.path.join(OUTPUT_DIR, \"lora\")  #@param {type:\"string\"}\n",
+        "\n",
+        "if RUN_PHASE_2:\n",
+        "    print(\"📋 Phase 2 Configuration:\")\n",
+        "    print(f\"   LLM:          {'FROZEN' if P2_FREEZE_LLM else 'TRAIN'}\")\n",
+        "    print(f\"   Diff. Head:   {'FROZEN' if P2_FREEZE_DIFFUSION_HEAD else 'TRAIN'}\")\n",
+        "    print(f\"   Surgery Mod:  {'FROZEN' if P2_FREEZE_SURGERY_MODULE else 'TRAIN'}\")\n",
+        "    print(f\"   Connectors:   {'FROZEN' if P2_FREEZE_CONNECTORS else 'TRAIN'}\")\n",
+        "    print(f\"   Head LoRA:    {'Yes' if P2_LORA_WRAP_DIFFUSION_HEAD else 'No'}\")\n",
+        "    print(f\"   LR:           {P2_LEARNING_RATE}\")\n",
+        "    print(f\"   Resume from:  {P2_RESUME_FROM}\")\n",
+        "else:\n",
+        "    print(\"Phase 2 is disabled. Set RUN_PHASE_2=True to enable.\")"
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {},
+      "source": [
+        "#@title 8.2 — Execute Phase 2 { display-mode: \"form\" }\n",
+        "\n",
+        "if RUN_PHASE_2:\n",
+        "    P2_OUTPUT_DIR = OUTPUT_DIR + \"_phase2\"\n",
+        "    \n",
+        "    p2_cmd = f\"\"\"\n",
+        "    python finetune_surgery_t4.py \\\n",
+        "        --model_name_or_path \"{SURGERY_MODEL_PATH}\" \\\n",
+        "        --processor_name_or_path \"{SURGERY_MODEL_PATH}\" \\\n",
+        "        --train_jsonl \"{TRAIN_JSONL_PATH}\" \\\n",
+        "        {f'--validation_jsonl \"{VALIDATION_JSONL_PATH}\"' if VALIDATION_JSONL_PATH else ''} \\\n",
+        "        --output_dir \"{P2_OUTPUT_DIR}\" \\\n",
+        "        --max_length {MAX_LENGTH} \\\n",
+        "        --num_train_epochs {P2_NUM_EPOCHS} \\\n",
+        "        --per_device_train_batch_size {BATCH_SIZE_PER_GPU} \\\n",
+        "        --gradient_accumulation_steps {GRADIENT_ACCUMULATION_STEPS} \\\n",
+        "        --learning_rate {P2_LEARNING_RATE} \\\n",
+        "        --warmup_ratio {WARMUP_RATIO} \\\n",
+        "        --weight_decay {WEIGHT_DECAY} \\\n",
+        "        --max_grad_norm {MAX_GRAD_NORM} \\\n",
+        "        --gradient_clipping \\\n",
+        "        --ddpm_batch_mul {DDPM_BATCH_MUL} \\\n",
+        "        --ce_loss_weight {CE_LOSS_WEIGHT} \\\n",
+        "        --diffusion_loss_weight {DIFFUSION_LOSS_WEIGHT} \\\n",
+        "        --voice_prompt_drop_rate {VOICE_PROMPT_DROP_RATE} \\\n",
+        "        --eval_split_size {EVAL_SPLIT_SIZE} \\\n",
+        "        --do_eval \\\n",
+        "        --logging_steps {LOGGING_STEPS} \\\n",
+        "        --save_steps {SAVE_STEPS} \\\n",
+        "        --save_total_limit {SAVE_TOTAL_LIMIT} \\\n",
+        "        --eval_steps {EVAL_STEPS} \\\n",
+        "        --evaluation_strategy steps \\\n",
+        "        --load_best_model_at_end \\\n",
+        "        --metric_for_best_model eval_loss \\\n",
+        "        --greater_is_better False \\\n",
+        "        --save_strategy steps \\\n",
+        "        --report_to tensorboard \\\n",
+        "        --run_name vibevoice_surgery_phase2 \\\n",
+        "        --seed {SEED} \\\n",
+        "        --dataloader_num_workers 2 \\\n",
+        "        --ignore_verifications \\\n",
+        "        --remove_unused_columns False \\\n",
+        "        --dataloader_pin_memory True \\\n",
+        "        --freeze_llm {str(P2_FREEZE_LLM).lower()} \\\n",
+        "        --freeze_diffusion_head {str(P2_FREEZE_DIFFUSION_HEAD).lower()} \\\n",
+        "        --freeze_surgery_module {str(P2_FREEZE_SURGERY_MODULE).lower()} \\\n",
+        "        --freeze_connectors {str(P2_FREEZE_CONNECTORS).lower()} \\\n",
+        "        --freeze_lm_head True \\\n",
+        "        --freeze_acoustic_tokenizer True \\\n",
+        "        --freeze_semantic_tokenizer True \\\n",
+        "        --lora_target_modules none \\\n",
+        "        --lora_wrap_diffusion_head {str(P2_LORA_WRAP_DIFFUSION_HEAD).lower()} \\\n",
+        "        --train_diffusion_head {str(not P2_FREEZE_DIFFUSION_HEAD).lower()} \\\n",
+        "        --train_connectors {str(not P2_FREEZE_CONNECTORS).lower()} \\\n",
+        "        --train_surgery_module {str(not P2_FREEZE_SURGERY_MODULE).lower()} \\\n",
+        "        {'--fp16' if USE_FP16 else ''} \\\n",
+        "        {'--bf16' if USE_BF16 else ''} \\\n",
+        "        --gradient_checkpointing\n",
+        "    \"\"\"\n",
+        "    \n",
+        "    print(\"🚀 Starting Phase 2 training...\")\n",
+        "    os.chdir(PROJECT_DIR)\n",
+        "    process = subprocess.Popen(p2_cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, universal_newlines=True, bufsize=1)\n",
+        "    for line in process.stdout:\n",
+        "        print(line, end='')\n",
+        "    process.wait()\n",
+        "    \n",
+        "    if process.returncode == 0:\n",
+        "        print(\"\\n✅ Phase 2 training completed!\")\n",
+        "    else:\n",
+        "        print(f\"\\n❌ Phase 2 failed with exit code: {process.returncode}\")\n",
+        "else:\n",
+        "    print(\"Phase 2 skipped (RUN_PHASE_2=False).\")"
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Cell 9: 💾 Export & Merge Trained Weights"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {},
+      "source": [
+        "#@title 9.1 — Merge LoRA Weights & Create Inference Model { display-mode: \"form\" }\n",
+        "\n",
+        "import os, sys, json, gc\n",
+        "import torch\n",
+        "\n",
+        "os.chdir(PROJECT_DIR)\n",
+        "sys.path.insert(0, PROJECT_DIR)\n",
+        "\n",
+        "MERGE_OUTPUT = os.path.join(OUTPUT_DIR, \"merged_inference\")  #@param {type:\"string\"}\n",
+        "\n",
+        "print(\"=\" * 60)\n",
+        "print(\"  Merging Trained Weights\")\n",
+        "print(\"=\" * 60)\n",
+        "\n",
+        "lora_dir = os.path.join(OUTPUT_DIR, \"lora\")\n",
+        "if not os.path.exists(lora_dir):\n",
+        "    raise FileNotFoundError(f\"No trained artifacts found at {lora_dir}\")\n",
+        "\n",
+        "# Apply patches\n",
+        "from vibevoice_surgery_colab import (\n",
+        "    _patch_vibevoice_config_for_qwen3,\n",
+        "    Qwen3SurgeryModule,\n",
+        "    load_surgery_model,\n",
+        "    save_surgery_model,\n",
+        "    QWEN3_HIDDEN_SIZE,\n",
+        "    DIFFUSION_HIDDEN_SIZE,\n",
+        "    SURGERY_LAYER_INDICES,\n",
+        ")\n",
+        "_patch_vibevoice_config_for_qwen3()\n",
+        "\n",
+        "# Load the base surgery model\n",
+        "print(\"\\n[1/5] Loading base surgery model...\")\n",
+        "model = load_surgery_model(SURGERY_MODEL_PATH, dtype=torch.float16, device_map=\"cpu\")\n",
+        "\n",
+        "# Load LLM LoRA weights\n",
+        "print(\"\\n[2/5] Loading LLM LoRA weights...\")\n",
+        "try:\n",
+        "    from peft import load_peft_weights, set_peft_model_state_dict\n",
+        "    adapters_weights = load_peft_weights(lora_dir)\n",
+        "    set_peft_model_state_dict(model.model.language_model, adapters_weights)\n",
+        "    # Merge LoRA into base weights\n",
+        "    model.model.language_model = model.model.language_model.merge_and_unload()\n",
+        "    print(\"  ✅ LLM LoRA merged\")\n",
+        "except Exception as e:\n",
+        "    print(f\"  ℹ️  No LLM LoRA found (expected if LLM was frozen): {e}\")\n",
+        "\n",
+        "# Load Diffusion Head\n",
+        "print(\"\\n[3/5] Loading Diffusion Head weights...\")\n",
+        "ph_path = os.path.join(lora_dir, \"diffusion_head_full.bin\")\n",
+        "if os.path.exists(ph_path):\n",
+        "    model.model.prediction_head.load_state_dict(\n",
+        "        torch.load(ph_path, map_location=\"cpu\"), strict=False\n",
+        "    )\n",
+        "    print(\"  ✅ Diffusion Head loaded\")\n",
+        "\n",
+        "# Load Connectors\n",
+        "print(\"\\n[4/5] Loading Connectors...\")\n",
+        "for conn_name in [\"acoustic_connector\", \"semantic_connector\"]:\n",
+        "    conn_path = os.path.join(lora_dir, conn_name, \"pytorch_model.bin\")\n",
+        "    conn = getattr(model.model, conn_name, None)\n",
+        "    if os.path.exists(conn_path) and conn is not None:\n",
+        "        conn.load_state_dict(torch.load(conn_path, map_location=\"cpu\"))\n",
+        "        print(f\"  ✅ {conn_name} loaded\")\n",
+        "\n",
+        "# Load Surgery Module\n",
+        "print(\"\\n[5/5] Loading Surgery Module...\")\n",
+        "sm_path = os.path.join(lora_dir, \"surgery_module\", \"pytorch_model.bin\")\n",
+        "if os.path.exists(sm_path) and hasattr(model.model, \"surgery_module\"):\n",
+        "    model.model.surgery_module.load_state_dict(\n",
+        "        torch.load(sm_path, map_location=\"cpu\")\n",
+        "    )\n",
+        "    print(\"  ✅ Surgery Module loaded\")\n",
+        "\n",
+        "# Save merged model\n",
+        "print(f\"\\n💾 Saving merged model to {MERGE_OUTPUT}...\")\n",
+        "save_surgery_model(model, MERGE_OUTPUT)\n",
+        "print(f\"\\n✅ Merged inference model saved to: {MERGE_OUTPUT}\")\n",
+        "\n",
+        "# Cleanup\n",
+        "del model\n",
+        "gc.collect()\n",
+        "torch.cuda.empty_cache()"
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Cell 10: 🎤 Quick Inference Test"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {},
+      "source": [
+        "#@title 10.1 — Load Merged Model for Inference { display-mode: \"form\" }\n",
+        "\n",
+        "import os, sys, gc, torch\n",
+        "\n",
+        "os.chdir(PROJECT_DIR)\n",
+        "sys.path.insert(0, PROJECT_DIR)\n",
+        "\n",
+        "from vibevoice_surgery_colab import (\n",
+        "    _patch_vibevoice_config_for_qwen3,\n",
+        "    load_surgery_model,\n",
+        ")\n",
+        "_patch_vibevoice_config_for_qwen3()\n",
+        "\n",
+        "MERGE_PATH = os.path.join(OUTPUT_DIR, \"merged_inference\")\n",
+        "\n",
+        "if not os.path.exists(MERGE_PATH):\n",
+        "    print(f\"⚠️  Merged model not found at {MERGE_PATH}\")\n",
+        "    print(f\"   Using base surgery model instead.\")\n",
+        "    MERGE_PATH = SURGERY_MODEL_PATH\n",
+        "\n",
+        "print(f\"Loading model from {MERGE_PATH}...\")\n",
+        "inference_model = load_surgery_model(\n",
+        "    MERGE_PATH,\n",
+        "    dtype=torch.float16,\n",
+        "    device_map=\"auto\",\n",
+        ")\n",
+        "inference_model.eval()\n",
+        "print(\"✅ Model loaded for inference!\")"
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {},
+      "source": [
+        "#@title 10.2 — Generate Speech { display-mode: \"form\" }\n",
+        "\n",
+        "import torch, soundfile as sf\n",
+        "from vibevoice.processor.vibevoice_processor import VibeVoiceProcessor\n",
+        "\n",
+        "TEXT_TO_SPEAK = \"Hello, this is a test of the fine-tuned voice model.\"  #@param {type:\"string\"}\n",
+        "VOICE_PROMPT_PATH = \"\"  #@param {type:\"string\"}\n",
+        "CFG_SCALE = 3.0  #@param {type:\"number\"}\n",
+        "OUTPUT_AUDIO_PATH = \"/content/generated_speech.wav\"  #@param {type:\"string\"}\n",
+        "\n",
+        "# Load processor\n",
+        "processor = VibeVoiceProcessor.from_pretrained(MERGE_PATH)\n",
+        "\n",
+        "# Prepare inputs\n",
+        "if VOICE_PROMPT_PATH and os.path.exists(VOICE_PROMPT_PATH):\n",
+        "    proc_out = processor(\n",
+        "        text=[TEXT_TO_SPEAK],\n",
+        "        voice_samples=[[VOICE_PROMPT_PATH]],\n",
+        "        return_tensors=\"pt\",\n",
+        "    )\n",
+        "else:\n",
+        "    proc_out = processor(\n",
+        "        text=[TEXT_TO_SPEAK],\n",
+        "        return_tensors=\"pt\",\n",
+        "    )\n",
+        "\n",
+        "print(f\"Input tokens: {proc_out['input_ids'].shape}\")\n",
+        "\n",
+        "# Generate\n",
+        "print(\"\\n🎤 Generating speech...\")\n",
+        "with torch.no_grad():\n",
+        "    output = inference_model.generate(\n",
+        "        **{k: v.to(inference_model.device) if isinstance(v, torch.Tensor) else v \n",
+        "            for k, v in proc_out.items()},\n",
+        "        tokenizer=processor.tokenizer,\n",
+        "        cfg_scale=CFG_SCALE,\n",
+        "        max_new_tokens=2048,\n",
+        "        show_progress_bar=True,\n",
+        "    )\n",
+        "\n",
+        "# Save audio\n",
+        "if output.speech_outputs and output.speech_outputs[0] is not None:\n",
+        "    audio = output.speech_outputs[0].cpu().float().numpy()\n",
+        "    sf.write(OUTPUT_AUDIO_PATH, audio, 24000)\n",
+        "    print(f\"\\n✅ Audio saved to: {OUTPUT_AUDIO_PATH}\")\n",
+        "    print(f\"   Duration: {len(audio) / 24000:.2f} seconds\")\n",
+        "    print(f\"   Shape: {audio.shape}\")\n",
+        "else:\n",
+        "    print(\"❌ No audio generated. Check the input and model.\")"
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {},
+      "source": [
+        "#@title 10.3 — Play Generated Audio { display-mode: \"form\" }\n",
+        "\n",
+        "from IPython.display import Audio, display\n",
+        "\n",
+        "if os.path.exists(OUTPUT_AUDIO_PATH):\n",
+        "    display(Audio(OUTPUT_AUDIO_PATH))\n",
+        "else:\n",
+        "    print(\"No audio file found. Run Cell 10.2 first.\")"
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Cell 11: 📦 Download & Cleanup"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "metadata": {},
+      "source": [
+        "#@title 11.1 — Package Results for Download { display-mode: \"form\" }\n",
+        "\n",
+        "import shutil, os\n",
+        "\n",
+        "ZIP_OUTPUT = \"/content/vibevoice_finetuned.zip\"  #@param {type:\"string\"}\n",
+        "\n",
+        "# Package the trained artifacts\n",
+        "lora_dir = os.path.join(OUTPUT_DIR, \"lora\")\n",
+        "if os.path.exists(lora_dir):\n",
+        "    print(f\"📦 Packaging {lora_dir}...\")\n",
+        "    shutil.make_archive(\n",
+        "        ZIP_OUTPUT.replace('.zip', ''),\n",
+        "        'zip',\n",
+        "        lora_dir,\n",
+        "    )\n",
+        "    size_mb = os.path.getsize(ZIP_OUTPUT) / 1024 / 1024\n",
+        "    print(f\"✅ Package created: {ZIP_OUTPUT} ({size_mb:.1f} MB)\")\n",
+        "    \n",
+        "    # In Colab, you can download with:\n",
+        "    try:\n",
+        "        from google.colab import files\n",
+        "        files.download(ZIP_OUTPUT)\n",
+        "    except ImportError:\n",
+        "        print(f\"  (Not in Colab — download {ZIP_OUTPUT} manually)\")\n",
+        "else:\n",
+        "    print(f\"❌ No trained artifacts found at {lora_dir}\")"
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "metadata": {},
+      "source": [
+        "#@title 11.2 — Upload to Google Drive { display-mode: \"form\" }\n",
+        "\n",
+        "UPLOAD_TO_DRIVE = False  #@param {type:\"boolean\"}\n",
+        "DRIVE_PATH = \"/content/drive/MyDrive/vibevoice_finetuned\"  #@param {type:\"string\"}\n",
+        "\n",
+        "if UPLOAD_TO_DRIVE:\n",
+        "    import shutil\n",
+        "    \n",
+        "    # Mount Drive\n",
+        "    try:\n",
+        "        from google.colab import drive\n",
+        "        drive.mount('/content/drive')\n",
+        "    except ImportError:\n",
+        "        print(\"❌ Not running in Google Colab.\")\n",
+        "        UPLOAD_TO_DRIVE = False\n",
+        "    \n",
+        "    if UPLOAD_TO_DRIVE:\n",
+        "        os.makedirs(DRIVE_PATH, exist_ok=True)\n",
+        "        lora_dir = os.path.join(OUTPUT_DIR, \"lora\")\n",
+        "        if os.path.exists(lora_dir):\n",
+        "            print(f\"📤 Copying to Google Drive: {DRIVE_PATH}\")\n",
+        "            shutil.copytree(lora_dir, os.path.join(DRIVE_PATH, \"lora\"), dirs_exist_ok=True)\n",
+        "            print(f\"✅ Uploaded to Google Drive!\")\n",
+        "        \n",
+        "        # Also copy merged model if exists\n",
+        "        merged = os.path.join(OUTPUT_DIR, \"merged_inference\")\n",
+        "        if os.path.exists(merged):\n",
+        "            shutil.copytree(merged, os.path.join(DRIVE_PATH, \"merged\"), dirs_exist_ok=True)\n",
+        "            print(f\"✅ Merged model uploaded too!\")\n",
+        "else:\n",
+        "    print(\"Drive upload disabled.\")"
+      ],
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "---\n",
+        "\n",
+        "## 📖 Quick Reference\n",
+        "\n",
+        "### CLI Usage (alternative to notebook)\n",
+        "\n",
+        "```bash\n",
+        "# Phase 1: Train Surgery Module + Connectors (freeze LLM + Diffusion Head)\n",
+        "python finetune_surgery_t4.py \\\n",
+        "    --model_name_or_path /path/to/surgery_model \\\n",
+        "    --train_jsonl /path/to/train.jsonl \\\n",
+        "    --output_dir /path/to/output \\\n",
+        "    --freeze_llm true \\\n",
+        "    --freeze_diffusion_head true \\\n",
+        "    --freeze_surgery_module false \\\n",
+        "    --freeze_connectors false \\\n",
+        "    --train_connectors true \\\n",
+        "    --train_surgery_module true \\\n",
+        "    --lora_target_modules none \\\n",
+        "    --fp16 \\\n",
+        "    --gradient_checkpointing \\\n",
+        "    --num_train_epochs 3 \\\n",
+        "    --learning_rate 2e-5\n",
+        "\n",
+        "# Phase 2: Add Diffusion Head training\n",
+        "python finetune_surgery_t4.py \\\n",
+        "    --model_name_or_path /path/to/surgery_model \\\n",
+        "    --train_jsonl /path/to/train.jsonl \\\n",
+        "    --output_dir /path/to/output_phase2 \\\n",
+        "    --freeze_llm true \\\n",
+        "    --freeze_diffusion_head false \\\n",
+        "    --lora_wrap_diffusion_head true \\\n",
+        "    --train_connectors true \\\n",
+        "    --train_surgery_module true \\\n",
+        "    --lora_target_modules none \\\n",
+        "    --fp16 \\\n",
+        "    --gradient_checkpointing \\\n",
+        "    --num_train_epochs 2 \\\n",
+        "    --learning_rate 1e-5\n",
+        "```\n",
+        "\n",
+        "### Layer Freezing Flags\n",
+        "\n",
+        "| Flag | Default | Description |\n",
+        "|------|---------|-------------|\n",
+        "| `--freeze_llm` | True | Freeze entire LLM backbone |\n",
+        "| `--freeze_diffusion_head` | True | Freeze diffusion prediction head |\n",
+        "| `--freeze_surgery_module` | False | Freeze the 2560→3584 bridge |\n",
+        "| `--freeze_connectors` | False | Freeze acoustic/semantic connectors |\n",
+        "| `--freeze_lm_head` | True | Freeze LM output head |\n",
+        "| `--freeze_acoustic_tokenizer` | True | Freeze acoustic VAE |\n",
+        "| `--freeze_semantic_tokenizer` | True | Freeze semantic VAE |\n",
+        "| `--train_diffusion_head` | False | Full fine-tune diffusion head |\n",
+        "| `--train_connectors` | True | Full fine-tune connectors |\n",
+        "| `--train_surgery_module` | True | Full fine-tune surgery module |\n",
+        "| `--lora_target_modules` | q,k,v,o,... | LLM LoRA targets (\"none\" to disable) |\n",
+        "| `--lora_wrap_diffusion_head` | False | Apply LoRA to diffusion head |\n",
+        "| `--layers_to_freeze` | None | Specific diffusion head param indices to freeze |\n",
+        "\n",
+        "### Saved Artifacts Structure\n",
+        "\n",
+        "```\n",
+        "output_dir/\n",
+        "├── lora/\n",
+        "│   ├── adapter_config.json          # LLM LoRA config\n",
+        "│   ├── adapter_model.safetensors    # LLM LoRA weights\n",
+        "│   ├── diffusion_head/\n",
+        "│   │   ├── adapter_config.json      # Head LoRA config\n",
+        "│   │   ├── adapter_model.safetensors\n",
+        "│   │   └── diffusion_head_full.bin  # Full head weights\n",
+        "│   ├── acoustic_connector/\n",
+        "│   │   └── pytorch_model.bin\n",
+        "│   ├── semantic_connector/\n",
+        "│   │   └── pytorch_model.bin\n",
+        "│   └── surgery_module/\n",
+        "│       └── pytorch_model.bin\n",
+        "├── checkpoint-500/\n",
+        "├── checkpoint-1000/\n",
+        "└── merged_inference/              # (if Cell 9.1 ran)\n",
+        "    ├── config.json\n",
+        "    ├── model.safetensors\n",
+        "    └── preprocessor_config.json\n",
+        "```\n",
+        "\n",
+        "---\n",
+        "\n",
+        "*Built with ❤️ for the VibeVoice project*"
+      ]
+    }
+  ]
+}

VibeVoice-tpu/src/finetune_surgery_t4.py

@@ -0,0 +1,1214 @@
+"""
+VibeVoice Surgery Fine-Tuning on 2× T4 GPUs
+=============================================
+
+Complete fine-tuning pipeline for the VibeVoice surgery model (Qwen3-4B backbone).
+Designed for Kaggle / Google Colab with 2× NVIDIA T4 GPUs (16 GB VRAM each).
+
+Supports:
+  - Configurable layer freezing (LLM, Diffusion Head, Surgery Module, Connectors)
+  - LoRA on LLM and/or Diffusion Head
+  - Phase-based training (Phase 1: freeze LLM+head, Phase 2: unfreeze)
+  - Multi-GPU via DataParallel / DDP
+  - fp16 mixed precision (T4 native)
+  - Gradient checkpointing for memory efficiency
+  - EMA on prediction head
+  - Checkpoint resume with custom weight loading
+  - Comprehensive diagnostics and logging
+"""
+
+import os
+os.environ["TOKENIZERS_PARALLELISM"] = "false"
+
+import gc
+import json
+import copy
+import logging
+import random
+from dataclasses import dataclass, field
+from typing import Any, Dict, List, Optional, Tuple
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+from datasets import load_dataset, DatasetDict, VerificationMode
+from transformers import (
+    HfArgumentParser,
+    Trainer,
+    set_seed,
+    TrainerCallback,
+)
+from transformers import TrainingArguments as HfTrainingArguments
+from transformers.models.llama.modeling_llama import LlamaRMSNorm
+
+from peft import LoraConfig, get_peft_model, TaskType
+
+# VibeVoice imports
+from vibevoice.modular.modeling_vibevoice import (
+    VibeVoiceModel,
+    VibeVoiceForConditionalGeneration,
+    SpeechConnector,
+)
+from vibevoice.modular.configuration_vibevoice import VibeVoiceConfig
+from vibevoice.processor.vibevoice_processor import VibeVoiceProcessor
+
+# Surgery imports — monkey-patch for Qwen3 support
+try:
+    from vibevoice_surgery_colab import (
+        _patch_vibevoice_config_for_qwen3,
+        Qwen3SurgeryModule,
+        load_surgery_model,
+        QWEN3_HIDDEN_SIZE,
+        DIFFUSION_HIDDEN_SIZE,
+        SURGERY_LAYER_INDICES,
+    )
+    _patch_vibevoice_config_for_qwen3()
+except ImportError:
+    raise ImportError(
+        "vibevoice_surgery_colab.py must be in the same directory. "
+        "This script depends on the surgery module definition and patch."
+    )
+
+from data_vibevoice import VibeVoiceDataset, VibeVoiceCollator
+
+logger = logging.getLogger(__name__)
+
+
+# ============================================================================
+# SECTION 1: Argument Dataclasses
+# ============================================================================
+
+@dataclass
+class ModelArguments:
+    """Arguments for model loading and component configuration."""
+    model_name_or_path: Optional[str] = field(
+        default=None,
+        metadata={"help": "Path to the surgery model directory (saved by vibevoice_surgery_colab.py)"},
+    )
+    processor_name_or_path: Optional[str] = field(
+        default=None,
+        metadata={"help": "Path to processor dir. Defaults to model_name_or_path."},
+    )
+    cache_dir: Optional[str] = field(default=None)
+
+    # ── Freezing Strategy ──
+    freeze_llm: bool = field(
+        default=True,
+        metadata={"help": "Freeze the LLM (Qwen3) entirely. Set False for full fine-tune or LoRA."},
+    )
+    freeze_diffusion_head: bool = field(
+        default=True,
+        metadata={"help": "Freeze the Diffusion Head (prediction_head)."},
+    )
+    freeze_surgery_module: bool = field(
+        default=False,
+        metadata={"help": "Freeze the Surgery Module (2560→3584 bridge)."},
+    )
+    freeze_connectors: bool = field(
+        default=False,
+        metadata={"help": "Freeze acoustic and semantic connectors."},
+    )
+    freeze_acoustic_tokenizer: bool = field(default=True)
+    freeze_semantic_tokenizer: bool = field(default=True)
+    freeze_lm_head: bool = field(
+        default=True,
+        metadata={"help": "Freeze LM head. Should be True when LLM is frozen (tied weights)."},
+    )
+
+    # ── LoRA Configuration ──
+    lora_r: int = field(default=8)
+    lora_alpha: int = field(default=32)
+    lora_dropout: float = field(default=0.05)
+    lora_target_modules: str = field(
+        default="q_proj,k_proj,v_proj,o_proj,gate_proj,up_proj,down_proj",
+        metadata={"help": "Comma-separated LoRA target modules for LLM. Use 'none' to disable."},
+    )
+    lora_wrap_diffusion_head: bool = field(
+        default=False,
+        metadata={"help": "Apply LoRA to the Diffusion Head."},
+    )
+
+    # ── Fine-tune flags ──
+    train_diffusion_head: bool = field(
+        default=False,
+        metadata={"help": "Full fine-tune the Diffusion Head (overrides freeze_diffusion_head)."},
+    )
+    train_connectors: bool = field(
+        default=True,
+        metadata={"help": "Full fine-tune acoustic/semantic connectors."},
+    )
+    train_surgery_module: bool = field(
+        default=True,
+        metadata={"help": "Full fine-tune the Surgery Module."},
+    )
+
+    # ── Advanced ──
+    layers_to_freeze: Optional[str] = field(
+        default=None,
+        metadata={"help": "Comma-separated indices of diffusion head params to freeze (e.g., '0,1,5')."},
+    )
+
+
+@dataclass
+class DataArguments:
+    """Arguments for dataset loading and preprocessing."""
+    dataset_name: Optional[str] = field(default=None)
+    dataset_config_name: Optional[str] = field(default=None)
+    train_split_name: str = field(default="train")
+    eval_split_name: Optional[str] = field(default="validation")
+    text_column_name: str = field(default="text")
+    audio_column_name: str = field(default="audio")
+    voice_prompts_column_name: Optional[str] = field(default="voice_prompts")
+    eval_split_size: float = field(default=0.0)
+    ignore_verifications: bool = field(default=False)
+    max_length: Optional[int] = field(default=None)
+    train_jsonl: Optional[str] = field(default=None)
+    validation_jsonl: Optional[str] = field(default=None)
+    voice_prompt_drop_rate: float = field(default=0.0)
+
+
+@dataclass
+class CustomTrainingArguments(HfTrainingArguments):
+    """Extended training arguments for VibeVoice surgery fine-tuning."""
+    ddpm_batch_mul: int = field(default=1)
+    ce_loss_weight: float = field(default=1.0)
+    diffusion_loss_weight: float = field(default=1.0)
+    gradient_clipping: bool = field(
+        default=False,
+        metadata={"help": "Enable gradient clipping with max_grad_norm."},
+    )
+    debug_ce_details: bool = field(default=False)
+    debug_ce_topk: int = field(default=5)
+    debug_ce_max_examples: int = field(default=1)
+    debug_ce_every_n_steps: int = field(default=200)
+    debug_save: bool = field(default=False)
+
+
+# ============================================================================
+# SECTION 2: LoRA Configuration Builders
+# ============================================================================
+
+def build_lora_config(args: ModelArguments) -> LoraConfig:
+    """Build LoRA config for the LLM."""
+    target_modules = [s.strip() for s in args.lora_target_modules.split(",") if s.strip()]
+    return LoraConfig(
+        r=args.lora_r,
+        lora_alpha=args.lora_alpha,
+        lora_dropout=args.lora_dropout,
+        bias="none",
+        task_type=TaskType.CAUSAL_LM,
+        target_modules=target_modules,
+    )
+
+
+def build_head_lora_config(args: ModelArguments) -> LoraConfig:
+    """Build LoRA config for the Diffusion Head."""
+    target_modules = [
+        "noisy_images_proj", "cond_proj",
+        "gate_proj", "up_proj", "down_proj", "linear",
+    ]
+    return LoraConfig(
+        r=args.lora_r,
+        lora_alpha=args.lora_alpha,
+        lora_dropout=args.lora_dropout,
+        bias="none",
+        task_type=TaskType.FEATURE_EXTRACTION,
+        target_modules=target_modules,
+    )
+
+
+# ============================================================================
+# SECTION 3: Helper Functions
+# ============================================================================
+
+def mask_for_ce(
+    labels: torch.Tensor,
+    attention_mask: torch.Tensor,
+    acoustic_input_mask: torch.Tensor,
+    pad_id: int = -100,
+) -> torch.Tensor:
+    """Build CE loss mask: only predict text tokens, not acoustic placeholders."""
+    shifted = labels[:, 1:].contiguous()
+    base_mask = (
+        attention_mask[:, 1:].contiguous().eq(1)
+        if (attention_mask is not None and attention_mask.numel() > 0)
+        else torch.ones_like(shifted, dtype=torch.bool)
+    )
+    label_is_acoustic = acoustic_input_mask[:, 1:].contiguous()
+    final_mask = base_mask & (~label_is_acoustic)
+    out = shifted.clone()
+    out[~final_mask] = pad_id
+    return out
+
+
+def _patch_acoustic_encode_for_legacy_indexing(model_obj, logger_):
+    """Patch acoustic tokenizer encode to return [[...]] for legacy indexing."""
+    try:
+        acoustic = getattr(getattr(model_obj, "model", model_obj), "acoustic_tokenizer", None)
+        if acoustic is None or not hasattr(acoustic, "encode"):
+            logger_.warning("No acoustic_tokenizer.encode() found to patch.")
+            return
+        base_encode = acoustic.encode
+
+        def encode_wrapped(*args, **kwargs):
+            out = base_encode(*args, **kwargs)
+            try:
+                _ = out[0][0]
+                return out
+            except Exception:
+                pass
+            if isinstance(out, dict):
+                for k in ("frames", "codes", "tokens", "latents", "hidden_states"):
+                    if k in out:
+                        return [[out[k]]]
+                if len(out) > 0:
+                    return [[next(iter(out.values()))]]
+            for attr in ("frames", "codes", "tokens", "latents", "hidden_states"):
+                if hasattr(out, attr):
+                    return [[getattr(out, attr)]]
+            try:
+                if isinstance(out, torch.Tensor):
+                    return [[out]]
+            except Exception:
+                pass
+            return [[out]]
+
+        acoustic.encode = encode_wrapped
+        logger_.info("Patched acoustic_tokenizer.encode() for legacy indexing.")
+    except Exception as e:
+        logger_.warning(f"Failed to patch acoustic_tokenizer.encode(): {e}")
+
+
+def _force_output_hidden_states(model):
+    """Monkey-patch the base model to always output hidden_states."""
+    original_forward = model.model.forward
+    import functools
+
+    @functools.wraps(original_forward)
+    def patched_forward(self, **kwargs):
+        kwargs["output_hidden_states"] = True
+        return original_forward(**kwargs)
+
+    model.model.forward = patched_forward.__get__(model.model, type(model.model))
+    logger.info("Patched VibeVoiceModel.forward to force output_hidden_states=True")
+
+
+def print_model_summary(model, logger_):
+    """Print a comprehensive summary of trainable vs frozen parameters."""
+    components = {
+        "LLM (language_model)": getattr(model.model, "language_model", None),
+        "LM Head": getattr(model, "lm_head", None),
+        "Diffusion Head (prediction_head)": getattr(model.model, "prediction_head", None),
+        "Surgery Module": getattr(model.model, "surgery_module", None),
+        "Acoustic Connector": getattr(model.model, "acoustic_connector", None),
+        "Semantic Connector": getattr(model.model, "semantic_connector", None),
+        "Acoustic Tokenizer": getattr(model.model, "acoustic_tokenizer", None),
+        "Semantic Tokenizer": getattr(model.model, "semantic_tokenizer", None),
+    }
+
+    total_all = 0
+    total_train = 0
+    logger_.info("=" * 70)
+    logger_.info("  MODEL PARAMETER SUMMARY")
+    logger_.info("=" * 70)
+
+    for name, mod in components.items():
+        if mod is None:
+            logger_.info(f"  {name:<40s} NOT FOUND")
+            continue
+        n_all = sum(p.numel() for p in mod.parameters())
+        n_train = sum(p.numel() for p in mod.parameters() if p.requires_grad)
+        pct = (100.0 * n_train / n_all) if n_all > 0 else 0.0
+        status = "TRAINABLE" if n_train > 0 else "FROZEN"
+        if n_train > 0 and n_train < n_all:
+            status = f"PARTIAL ({pct:.1f}%)"
+        logger_.info(f"  {name:<40s} {n_all:>14,}  total  |  {n_train:>14,}  train  |  {status}")
+        total_all += n_all
+        total_train += n_train
+
+    logger_.info("-" * 70)
+    logger_.info(f"  {'TOTAL':<40s} {total_all:>14,}  total  |  {total_train:>14,}  train")
+    logger_.info(f"  Trainable percentage: {100.0 * total_train / max(total_all, 1):.2f}%")
+    logger_.info("=" * 70)
+
+
+# ============================================================================
+# SECTION 4: EMA Callback
+# ============================================================================
+
+class EmaCallback(TrainerCallback):
+    """Exponential Moving Average for the prediction head."""
+
+    def __init__(self, attr_path="model.prediction_head", decay=0.999, device="cuda"):
+        self.attr_path = attr_path
+        self.decay = float(decay)
+        self.device = torch.device(device)
+        self.shadow = None
+        self._orig = None
+
+    def _get_module(self, model):
+        mod = model
+        for name in self.attr_path.split('.'):
+            mod = getattr(mod, name)
+        return mod
+
+    def on_train_begin(self, args, state, control, model=None, **kwargs):
+        head = self._get_module(model)
+        self.shadow = {
+            k: p.detach().to(self.device).clone()
+            for k, p in head.state_dict().items()
+        }
+
+    def on_step_end(self, args, state, control, model=None, **kwargs):
+        if self.shadow is None:
+            return
+        head = self._get_module(model)
+        with torch.no_grad():
+            for k, v in head.state_dict().items():
+                self.shadow[k].mul_(self.decay).add_(
+                    v.detach().to(self.device), alpha=(1.0 - self.decay)
+                )
+
+    def _swap_in_ema(self, model):
+        head = self._get_module(model)
+        self._orig = copy.deepcopy(head.state_dict())
+        head.load_state_dict(self.shadow, strict=False)
+
+    def _swap_back(self, model):
+        if self._orig is None:
+            return
+        head = self._get_module(model)
+        head.load_state_dict(self._orig, strict=False)
+        self._orig = None
+
+    def on_evaluate(self, args, state, control, model=None, **kwargs):
+        self._swap_in_ema(model)
+
+    def on_evaluate_end(self, args, state, control, model=None, **kwargs):
+        self._swap_back(model)
+
+    def on_save(self, args, state, control, model=None, **kwargs):
+        self._swap_in_ema(model)
+
+    def on_save_end(self, args, state, control, model=None, **kwargs):
+        self._swap_back(model)
+
+    def on_train_end(self, args, state, control, model=None, **kwargs):
+        self._swap_in_ema(model)
+
+
+# ============================================================================
+# SECTION 5: LoRA Debug Callback
+# ============================================================================
+
+class LoRADebugCallback(TrainerCallback):
+    """Monitor LoRA parameter changes during training."""
+
+    def __init__(self, log_every_n_steps: int = 50):
+        self.log_every_n_steps = max(1, int(log_every_n_steps))
+        self.prev_param_norms: Dict[str, float] = {}
+        self.lora_param_names: List[str] = []
+
+    def on_train_begin(self, args, state, control, model=None, **kwargs):
+        try:
+            if model is None:
+                return
+            named = dict(model.named_parameters())
+            self.lora_param_names = [
+                n for n in named if ("lora_A" in n or "lora_B" in n)
+            ]
+            for n in self.lora_param_names:
+                self.prev_param_norms[n] = float(named[n].data.norm().item())
+            total = len(self.lora_param_names)
+            req_grad = sum(1 for n in self.lora_param_names if named[n].requires_grad)
+            logger.info(f"LoRA debug: {total} LoRA params, {req_grad} trainable.")
+        except Exception as e:
+            logger.warning(f"LoRA debug init failed: {e}")
+
+    def on_step_end(self, args, state, control, model=None, **kwargs):
+        try:
+            if model is None or not self.lora_param_names:
+                return
+            step = int(getattr(state, "global_step", 0) or 0)
+            if step % self.log_every_n_steps != 0 and step != 1:
+                return
+            named = dict(model.named_parameters())
+            changed = 0
+            for n in self.lora_param_names:
+                p = named.get(n)
+                if p is None:
+                    continue
+                prev = self.prev_param_norms.get(n, 0.0)
+                curr = float(p.data.norm().item())
+                if abs(curr - prev) > 1e-12:
+                    changed += 1
+                self.prev_param_norms[n] = curr
+            logger.info(f"LoRA debug step {step}: {changed}/{len(self.lora_param_names)} params changed.")
+        except Exception as e:
+            logger.warning(f"LoRA debug step failed: {e}")
+
+
+# ============================================================================
+# SECTION 6: Custom Trainer with Surgery-aware Forward
+# ============================================================================
+
+class VibeVoiceSurgeryTrainer(Trainer):
+    """
+    Custom Trainer for VibeVoice Surgery model.
+
+    Key modification: When a surgery_module exists, condition features for
+    the diffusion head are projected through the Surgery Module (2560→3584)
+    before being fed to prediction_head.
+
+    Also handles:
+      - Dual loss (CE + Diffusion)
+      - Semantic tensor dtype alignment
+      - Diagnostics logging
+    """
+
+    def compute_loss(
+        self,
+        model: VibeVoiceForConditionalGeneration,
+        inputs: Dict[str, Any],
+        return_outputs=False,
+        num_items_in_batch: Optional[int] = None,
+    ):
+        labels = inputs.get("input_ids")
+        attention_mask = inputs.get("attention_mask")
+        acoustic_input_mask = inputs.get("acoustic_input_mask")
+
+        # Align semantic tensor dtype
+        sem = inputs.get("speech_semantic_tensors", None)
+        try:
+            target_dtype = next(model.model.semantic_connector.parameters()).dtype
+        except Exception:
+            target_dtype = model.get_input_embeddings().weight.dtype
+
+        if sem is None:
+            sm = inputs.get("speech_masks")
+            if sm is not None:
+                sem_dim = getattr(model.config, "semantic_vae_dim", 128)
+                inputs["speech_semantic_tensors"] = torch.zeros(
+                    sm.size(0), sm.size(1), sem_dim,
+                    dtype=target_dtype, device=sm.device,
+                )
+        elif isinstance(sem, torch.Tensor):
+            inputs["speech_semantic_tensors"] = sem.to(dtype=target_dtype)
+
+        # ── Forward through model ──
+        outputs = model(
+            input_ids=inputs.get("input_ids"),
+            attention_mask=attention_mask,
+            speech_tensors=inputs.get("speech_tensors"),
+            speech_masks=inputs.get("speech_masks"),
+            speech_semantic_tensors=inputs.get("speech_semantic_tensors"),
+            acoustic_input_mask=acoustic_input_mask,
+            acoustic_loss_mask=inputs.get("acoustic_loss_mask"),
+            speeches_loss_input=inputs.get("speeches_loss_input"),
+            ddpm_batch_mul=getattr(self.args, "ddpm_batch_mul", 1),
+            output_hidden_states=True,  # Required for surgery module
+        )
+
+        # ── CE Loss ──
+        logits = outputs.logits
+        ce_labels = mask_for_ce(labels, attention_mask, acoustic_input_mask, pad_id=-100)
+        shift_logits = logits[:, :-1, :].contiguous()
+        loss_fct = nn.CrossEntropyLoss(ignore_index=-100)
+        ce_loss = loss_fct(shift_logits.view(-1, shift_logits.size(-1)), ce_labels.view(-1))
+
+        # ── Diffusion Loss (Surgery-aware) ──
+        # The model's forward() computes diffusion_loss internally.
+        # For surgery models, we need to recompute with Surgery Module applied.
+        has_surgery = hasattr(model.model, "surgery_module")
+
+        if has_surgery and hasattr(outputs, "hidden_states") and outputs.hidden_states is not None:
+            # Recompute diffusion loss with surgery-projected conditions
+            diffusion_loss = self._compute_surgery_diffusion_loss(
+                model, inputs, outputs, acoustic_input_mask
+            )
+        else:
+            diffusion_loss = (
+                outputs.diffusion_loss
+                if outputs.diffusion_loss is not None
+                else torch.tensor(0.0, device=ce_loss.device)
+            )
+
+        # ── Combined Loss ──
+        total = (
+            getattr(self.args, "ce_loss_weight", 1.0) * ce_loss
+            + getattr(self.args, "diffusion_loss_weight", 1.0) * diffusion_loss
+        )
+
+        # ── Logging ──
+        try:
+            prefix = "train" if model.training else "eval"
+            self.log({
+                f"{prefix}/ce_loss": ce_loss.detach().item(),
+                f"{prefix}/diffusion_loss": (
+                    diffusion_loss.detach().item()
+                    if isinstance(diffusion_loss, torch.Tensor)
+                    else float(diffusion_loss)
+                ),
+            })
+            if hasattr(self, "optimizer") and self.optimizer is not None:
+                if len(self.optimizer.param_groups) > 0:
+                    lr_val = self.optimizer.param_groups[0].get("lr")
+                    if lr_val is not None:
+                        self.log({"train/learning_rate_real": float(lr_val)})
+        except Exception:
+            pass
+
+        return (total, outputs) if return_outputs else total
+
+    def _compute_surgery_diffusion_loss(
+        self,
+        model,
+        inputs,
+        outputs,
+        acoustic_input_mask,
+    ):
+        """
+        Compute diffusion loss using Surgery Module to project hidden states
+        from Qwen3 hidden_size (2560) to diffusion head hidden_size (3584).
+        """
+        speech_tensors = inputs.get("speech_tensors")
+        speech_masks = inputs.get("speech_masks")
+        acoustic_loss_mask = inputs.get("acoustic_loss_mask")
+        speeches_loss_input = inputs.get("speeches_loss_input")
+        ddpm_batch_mul = getattr(self.args, "ddpm_batch_mul", 1)
+
+        if speech_tensors is None or acoustic_loss_mask is None:
+            return sum(p.sum() for p in model.model.prediction_head.parameters()) * 0.0
+
+        if acoustic_loss_mask.sum().item() == 0:
+            return sum(p.sum() for p in model.model.prediction_head.parameters()) * 0.0
+
+        hidden_states = outputs.last_hidden_state
+
+        # Get ground truth acoustic features (64-dim latents)
+        x = model.get_input_embeddings()(inputs["input_ids"])
+        with torch.no_grad():
+            speech_all_features, _ = model.forward_speech_features(
+                speech_tensors=speech_tensors.type_as(x),
+                speech_masks=speech_masks,
+                return_unmask=True,
+            )
+        speech_features = speech_all_features[speeches_loss_input & speech_masks]
+
+        # Build condition from hidden states + Surgery Module
+        cond_mask = torch.zeros_like(acoustic_loss_mask, dtype=torch.bool)
+        cond_mask[:, :-1] = acoustic_loss_mask[:, 1:]
+        cond_mask[:, 0] = False
+        condition_features = hidden_states[cond_mask]
+
+        # Apply Surgery Module: 2560 → 3584
+        condition_features = model.model.surgery_module(condition_features)
+
+        speech_len, latent_size = speech_features.shape
+        noise = torch.randn(
+            (speech_len * ddpm_batch_mul, latent_size),
+            device=hidden_states.device,
+            dtype=hidden_states.dtype,
+        )
+        timesteps = torch.multinomial(
+            torch.ones(model.config.diffusion_head_config.ddpm_num_steps),
+            speech_len * ddpm_batch_mul,
+            replacement=True,
+        ).to(hidden_states.device)
+
+        speech_features_rep = speech_features.repeat_interleave(ddpm_batch_mul, dim=0)
+        condition_features_rep = condition_features.repeat_interleave(ddpm_batch_mul, dim=0)
+
+        noisy_speech = model.model.noise_scheduler.add_noise(speech_features_rep, noise, timesteps)
+        model_output = model.model.prediction_head(noisy_speech, timesteps.type_as(x), condition_features_rep)
+
+        prediction_type = model.config.diffusion_head_config.prediction_type
+        if prediction_type == "epsilon":
+            target = noise
+        elif prediction_type == "v_prediction":
+            target = model.model.noise_scheduler.get_velocity(speech_features_rep, noise, timesteps)
+        else:
+            raise NotImplementedError(f"Prediction type {prediction_type} not implemented")
+
+        loss = F.mse_loss(model_output.float(), target.float(), reduction="sum")
+        if latent_size > 0 and ddpm_batch_mul > 0:
+            loss = loss / latent_size / ddpm_batch_mul / max(speech_len, 1)
+        return loss
+
+    def _save(self, output_dir: Optional[str] = None, state_dict=None):
+        """Save LoRA adapters, connectors, surgery module, and diffusion head."""
+        try:
+            target_dir = output_dir or self.args.output_dir
+            lora_out = os.path.join(target_dir, "lora")
+            os.makedirs(lora_out, exist_ok=True)
+
+            # LLM LoRA adapters
+            lm = getattr(self.model.model, "language_model", None)
+            if hasattr(lm, "save_pretrained"):
+                lm.save_pretrained(lora_out)
+
+            # Diffusion Head LoRA adapters
+            ph = getattr(self.model.model, "prediction_head", None)
+            if hasattr(ph, "save_pretrained"):
+                ph_dir = os.path.join(lora_out, "diffusion_head")
+                os.makedirs(ph_dir, exist_ok=True)
+                ph.save_pretrained(ph_dir)
+
+            # Full diffusion head state_dict
+            if ph is not None and hasattr(ph, "state_dict"):
+                sd = ph.state_dict()
+                torch.save(sd, os.path.join(lora_out, "diffusion_head_full.bin"))
+
+            # Acoustic Connector
+            ac = getattr(self.model.model, "acoustic_connector", None)
+            if ac is not None:
+                ac_dir = os.path.join(lora_out, "acoustic_connector")
+                os.makedirs(ac_dir, exist_ok=True)
+                torch.save(ac.state_dict(), os.path.join(ac_dir, "pytorch_model.bin"))
+
+            # Semantic Connector
+            se = getattr(self.model.model, "semantic_connector", None)
+            if se is not None:
+                se_dir = os.path.join(lora_out, "semantic_connector")
+                os.makedirs(se_dir, exist_ok=True)
+                torch.save(se.state_dict(), os.path.join(se_dir, "pytorch_model.bin"))
+
+            # Surgery Module
+            sm = getattr(self.model.model, "surgery_module", None)
+            if sm is not None:
+                sm_dir = os.path.join(lora_out, "surgery_module")
+                os.makedirs(sm_dir, exist_ok=True)
+                torch.save(sm.state_dict(), os.path.join(sm_dir, "pytorch_model.bin"))
+                logger.info(f"Saved Surgery Module to {sm_dir}")
+
+        except Exception as e:
+            logger.warning(f"Failed to save custom assets: {e}")
+
+
+# ============================================================================
+# SECTION 7: Main Function
+# ============================================================================
+
+def main() -> None:
+    parser = HfArgumentParser((ModelArguments, DataArguments, CustomTrainingArguments))
+    model_args, data_args, training_args = parser.parse_args_into_dataclasses()
+
+    logging.basicConfig(
+        format="%(asctime)s - %(levelname)s - %(name)s - %(message)s",
+        datefmt="%m/%d/%Y %H:%M:%S",
+        level=logging.INFO if training_args.local_rank in [-1, 0] else logging.WARN,
+    )
+    logger.info("Training parameters: %s", training_args)
+    set_seed(training_args.seed)
+
+    # ── Gradient Clipping ──
+    if not getattr(training_args, "gradient_clipping", False):
+        training_args.max_grad_norm = 0.0
+        logger.info("Gradient clipping disabled. Use --gradient_clipping to enable.")
+    else:
+        if not training_args.max_grad_norm or training_args.max_grad_norm <= 0:
+            training_args.max_grad_norm = 1.0
+        logger.info(f"Gradient clipping: max_grad_norm={training_args.max_grad_norm}")
+
+    # ── Load Processor ──
+    processor_path = model_args.processor_name_or_path or model_args.model_name_or_path
+    if processor_path is None:
+        raise ValueError("--model_name_or_path must be provided")
+    processor = VibeVoiceProcessor.from_pretrained(processor_path)
+
+    tok = processor.tokenizer
+    for required in ["speech_start_id", "speech_diffusion_id", "speech_end_id"]:
+        if not hasattr(tok, required) or getattr(tok, required) is None:
+            raise RuntimeError(f"Tokenizer missing required special id: {required}")
+
+    # ── Load Surgery Model ──
+    if model_args.model_name_or_path is None:
+        raise ValueError("--model_name_or_path is required")
+
+    dtype = torch.float32
+    if training_args.bf16:
+        dtype = torch.bfloat16
+    elif getattr(training_args, "fp16", False):
+        dtype = torch.float16
+
+    logger.info(f"Loading surgery model from {model_args.model_name_or_path}...")
+    logger.info(f"  Dtype: {dtype}")
+
+    # Load using the surgery model loader (handles device_map, surgery module, patches)
+    surgery_model = load_surgery_model(
+        model_args.model_name_or_path,
+        dtype=dtype,
+        device_map="cpu",  # Load on CPU first for weight manipulation
+    )
+
+    _patch_acoustic_encode_for_legacy_indexing(surgery_model, logger)
+    processor.semantic_tokenizer = getattr(surgery_model.model, "semantic_tokenizer", None)
+
+    # ── Verify Surgery Module ──
+    has_surgery = hasattr(surgery_model.model, "surgery_module")
+    if has_surgery:
+        sm = surgery_model.model.surgery_module
+        logger.info(f"Surgery Module found: {sm.extra_repr()}")
+    else:
+        logger.warning("No Surgery Module found! This may be an unsurgeried model.")
+
+    # ── Verify Dimensions ──
+    lm_hidden = surgery_model.config.decoder_config.hidden_size
+    dh_hidden = surgery_model.config.diffusion_head_config.hidden_size
+    logger.info(f"  LLM hidden_size: {lm_hidden}")
+    logger.info(f"  Diffusion head hidden_size: {dh_hidden}")
+    if has_surgery:
+        logger.info(f"  Surgery Module: {lm_hidden} → {dh_hidden}")
+
+    # ── Tie LM Head ──
+    try:
+        emb = surgery_model.get_input_embeddings()
+        head = surgery_model.get_output_embeddings()
+        if hasattr(emb, "weight") and hasattr(head, "weight"):
+            if emb.weight.shape == head.weight.shape and emb.weight.data_ptr() != head.weight.data_ptr():
+                with torch.no_grad():
+                    head.weight = emb.weight
+                logger.info("Force-tied LM head to embed_tokens.")
+    except Exception as e:
+        logger.warning(f"Force-tie LM head failed: {e}")
+
+    # ── Disable Cache ──
+    if hasattr(surgery_model.config, "use_cache") and training_args.do_train:
+        surgery_model.config.use_cache = False
+
+    # ── Force output_hidden_states ──
+    _force_output_hidden_states(surgery_model)
+
+    # ======================================================================
+    # FREEZING STRATEGY
+    # ======================================================================
+    logger.info("\n" + "=" * 70)
+    logger.info("  CONFIGURING LAYER FREEZING")
+    logger.info("=" * 70)
+
+    # Step 1: Freeze ALL parameters
+    for _, p in surgery_model.named_parameters():
+        p.requires_grad = False
+    logger.info("  [1] All parameters frozen.")
+
+    # Step 2: Freeze tokenizers (always)
+    if model_args.freeze_acoustic_tokenizer and hasattr(surgery_model.model, "acoustic_tokenizer"):
+        for p in surgery_model.model.acoustic_tokenizer.parameters():
+            p.requires_grad = False
+        logger.info("  [2] Acoustic tokenizer: FROZEN")
+
+    if model_args.freeze_semantic_tokenizer and hasattr(surgery_model.model, "semantic_tokenizer"):
+        for p in surgery_model.model.semantic_tokenizer.parameters():
+            p.requires_grad = False
+        logger.info("  [2] Semantic tokenizer: FROZEN")
+
+    # Step 3: LoRA wrap LLM
+    tm_lower = [s.strip().lower() for s in model_args.lora_target_modules.split(",") if s.strip()]
+    skip_lm_lora = (len(tm_lower) == 0) or all(
+        t in ("none", "off", "disable", "disabled") for t in tm_lower
+    )
+
+    if not skip_lm_lora and not model_args.freeze_llm:
+        lora_cfg = build_lora_config(model_args)
+        surgery_model.model.language_model = get_peft_model(
+            surgery_model.model.language_model, lora_cfg
+        )
+        logger.info(f"  [3] LLM wrapped with LoRA (r={model_args.lora_r}, alpha={model_args.lora_alpha})")
+    elif model_args.freeze_llm:
+        logger.info("  [3] LLM: FROZEN (no LoRA)")
+    else:
+        logger.info("  [3] LLM LoRA: SKIPPED (target_modules=none)")
+
+    # Step 4: Re-enable trainable params
+    if not skip_lm_lora and not model_args.freeze_llm:
+        for n, p in surgery_model.model.language_model.named_parameters():
+            if "lora_A" in n or "lora_B" in n:
+                p.requires_grad = True
+        logger.info("  [4] LLM LoRA params: ENABLED")
+
+    # Step 5: Diffusion Head
+    if model_args.train_diffusion_head:
+        for p in surgery_model.model.prediction_head.parameters():
+            p.requires_grad = True
+        logger.info("  [5] Diffusion Head: FULL TRAIN")
+    elif model_args.lora_wrap_diffusion_head:
+        # LoRA wrap diffusion head
+        class _HeadShim(nn.Module):
+            def __init__(self, base):
+                super().__init__()
+                self.base = base
+
+            def forward(self, *args, **kwargs):
+                if len(args) >= 3:
+                    noisy_images, timesteps, condition = args[:3]
+                else:
+                    noisy_images = kwargs.get("noisy_images")
+                    timesteps = kwargs.get("timesteps")
+                    condition = kwargs.get("condition")
+                return self.base(noisy_images, timesteps, condition)
+
+        try:
+            shim = _HeadShim(surgery_model.model.prediction_head)
+            surgery_model.model.prediction_head = get_peft_model(shim, build_head_lora_config(model_args))
+            for n, p in surgery_model.model.prediction_head.named_parameters():
+                if "lora_A" in n or "lora_B" in n:
+                    p.requires_grad = True
+            logger.info("  [5] Diffusion Head: LoRA WRAPPED")
+        except Exception as e:
+            logger.warning(f"  [5] Diffusion Head LoRA failed: {e}")
+    elif model_args.freeze_diffusion_head:
+        logger.info("  [5] Diffusion Head: FROZEN")
+    else:
+        for p in surgery_model.model.prediction_head.parameters():
+            p.requires_grad = True
+        logger.info("  [5] Diffusion Head: FULL TRAIN (default unfrozen)")
+
+    # Step 6: Specific diffusion head layer freezing
+    if model_args.layers_to_freeze and hasattr(surgery_model.model, "prediction_head"):
+        head_params = list(surgery_model.model.prediction_head.named_parameters())
+        try:
+            indices = {int(x.strip()) for x in model_args.layers_to_freeze.split(",") if x.strip()}
+            frozen = 0
+            for i, (name, param) in enumerate(head_params):
+                if i in indices:
+                    param.requires_grad = False
+                    frozen += 1
+                    logger.info(f"    Froze diffusion head param [{i}]: {name}")
+            logger.info(f"  [6] Froze {frozen} diffusion head params by index.")
+        except Exception as e:
+            logger.error(f"  [6] layers_to_freeze parse error: {e}")
+
+    # Step 7: Surgery Module
+    if hasattr(surgery_model.model, "surgery_module"):
+        if model_args.freeze_surgery_module:
+            for p in surgery_model.model.surgery_module.parameters():
+                p.requires_grad = False
+            logger.info("  [7] Surgery Module: FROZEN")
+        else:
+            for p in surgery_model.model.surgery_module.parameters():
+                p.requires_grad = True
+            logger.info("  [7] Surgery Module: TRAINABLE")
+
+    # Step 8: Connectors
+    if model_args.train_connectors:
+        if hasattr(surgery_model.model, "acoustic_connector"):
+            for p in surgery_model.model.acoustic_connector.parameters():
+                p.requires_grad = True
+        if hasattr(surgery_model.model, "semantic_connector"):
+            for p in surgery_model.model.semantic_connector.parameters():
+                p.requires_grad = True
+        logger.info("  [8] Connectors: TRAINABLE")
+    elif model_args.freeze_connectors:
+        logger.info("  [8] Connectors: FROZEN")
+    else:
+        # Default: train connectors
+        if hasattr(surgery_model.model, "acoustic_connector"):
+            for p in surgery_model.model.acoustic_connector.parameters():
+                p.requires_grad = True
+        if hasattr(surgery_model.model, "semantic_connector"):
+            for p in surgery_model.model.semantic_connector.parameters():
+                p.requires_grad = True
+        logger.info("  [8] Connectors: TRAINABLE (default)")
+
+    # Step 9: Freeze embedding + LM head
+    try:
+        emb = surgery_model.get_input_embeddings()
+        if hasattr(emb, "weight"):
+            emb.weight.requires_grad_(False)
+        head = surgery_model.get_output_embeddings()
+        if head is not None and hasattr(head, "weight"):
+            if model_args.freeze_lm_head:
+                head.weight.requires_grad_(False)
+                logger.info("  [9] LM Head: FROZEN")
+            else:
+                logger.info("  [9] LM Head: TRAINABLE (weight-tied with embeddings)")
+    except Exception as e:
+        logger.warning(f"  [9] Embedding/head freeze failed: {e}")
+
+    # ── Print Summary ──
+    print_model_summary(surgery_model, logger)
+
+    # ── Move to GPU ──
+    if torch.cuda.device_count() > 1:
+        logger.info(f"Using {torch.cuda.device_count()} GPUs with DataParallel")
+        surgery_model = nn.DataParallel(surgery_model)
+    else:
+        device = torch.device("cuda:0")
+        surgery_model = surgery_model.to(device)
+        logger.info(f"Using single GPU: {device}")
+
+    # ======================================================================
+    # DATASETS
+    # ======================================================================
+
+    # Preprocessed data support
+    class PreprocessedBatchDataset:
+        def __init__(self, preprocessed_file: str):
+            self.data = torch.load(preprocessed_file, map_location="cpu")
+            logger.info(f"Loaded {len(self.data)} preprocessed batches from {preprocessed_file}")
+
+        def __len__(self):
+            return len(self.data)
+
+        def __getitem__(self, idx):
+            return self.data[idx]
+
+    class PreprocessedBatchSubset:
+        def __init__(self, dataset, indices):
+            self.dataset = dataset
+            self.indices = indices
+
+        def __len__(self):
+            return len(self.indices)
+
+        def __getitem__(self, idx):
+            return self.dataset[self.indices[idx]]
+
+    class PreprocessedBatchCollator:
+        def __call__(self, batch):
+            if not batch:
+                return {}
+            result = {}
+            for key in batch[0].keys():
+                tensors = [b[key] for b in batch if b[key] is not None]
+                if tensors and isinstance(tensors[0], torch.Tensor):
+                    result[key] = torch.cat(tensors, dim=0)
+                else:
+                    result[key] = tensors[0] if tensors else None
+            return result
+
+    preprocessed_dir = os.path.join(training_args.output_dir, "preprocessed")
+    preprocessed_file = os.path.join(preprocessed_dir, "preprocessed_batches.pt")
+
+    if os.path.exists(preprocessed_file):
+        logger.info(f"Loading preprocessed data from {preprocessed_file}")
+        preprocessed_data = PreprocessedBatchDataset(preprocessed_file)
+        train_dataset = preprocessed_data
+        eval_dataset = None
+
+        if training_args.do_eval and data_args.eval_split_size and data_args.eval_split_size > 0 and len(preprocessed_data) > 1:
+            num_eval = max(1, int(len(preprocessed_data) * data_args.eval_split_size))
+            num_train = len(preprocessed_data) - num_eval
+            indices = list(range(len(preprocessed_data)))
+            random.Random(training_args.seed).shuffle(indices)
+            train_dataset = PreprocessedBatchSubset(preprocessed_data, indices[:num_train])
+            eval_dataset = PreprocessedBatchSubset(preprocessed_data, indices[num_train:])
+    else:
+        logger.info("Preprocessed data not found, loading from raw JSONL/HF datasets")
+        verification_mode = VerificationMode.NO_CHECKS if data_args.ignore_verifications else VerificationMode.BASIC_CHECKS
+        if data_args.train_jsonl is not None:
+            data_files = {"train": data_args.train_jsonl}
+            if data_args.validation_jsonl is not None:
+                data_files["validation"] = data_args.validation_jsonl
+            raw = load_dataset("json", data_files=data_files, verification_mode=verification_mode, cache_dir=model_args.cache_dir)
+        else:
+            if data_args.dataset_name is None:
+                raise ValueError("Provide --dataset_name or --train_jsonl")
+            raw = load_dataset(
+                data_args.dataset_name,
+                data_args.dataset_config_name,
+                verification_mode=verification_mode,
+                cache_dir=model_args.cache_dir,
+            )
+        train_ds = raw[data_args.train_split_name]
+        eval_ds = None
+        if training_args.do_eval:
+            if data_args.eval_split_name and data_args.eval_split_name in raw:
+                eval_ds = raw[data_args.eval_split_name]
+            elif data_args.eval_split_size and data_args.eval_split_size > 0 and len(train_ds) > 1:
+                split = train_ds.train_test_split(test_size=data_args.eval_split_size, seed=training_args.seed)
+                train_ds, eval_ds = split["train"], split["test"]
+
+        train_dataset = VibeVoiceDataset(
+            train_ds,
+            text_column=data_args.text_column_name,
+            audio_column=data_args.audio_column_name,
+            voice_prompts_column=data_args.voice_prompts_column_name,
+        )
+        eval_dataset = None
+        if eval_ds is not None:
+            eval_dataset = VibeVoiceDataset(
+                eval_ds,
+                text_column=data_args.text_column_name,
+                audio_column=data_args.audio_column_name,
+                voice_prompts_column=data_args.voice_prompts_column_name,
+            )
+
+    # ── Collator ──
+    speech_compress_ratio = getattr(processor, "speech_tok_compress_ratio", 3200)
+    semantic_dim = getattr(surgery_model.config if not isinstance(surgery_model, nn.DataParallel) else surgery_model.module.config, "semantic_vae_dim", 128)
+    compute_semantics = hasattr(processor, "semantic_tokenizer") and processor.semantic_tokenizer is not None
+
+    if os.path.exists(preprocessed_file):
+        data_collator = PreprocessedBatchCollator()
+    else:
+        data_collator = VibeVoiceCollator(
+            processor=processor,
+            max_length=data_args.max_length,
+            speech_compress_ratio=speech_compress_ratio,
+            semantic_vae_dim=semantic_dim,
+            compute_semantics=compute_semantics,
+            debug_checks=False,
+            voice_prompt_drop_rate=data_args.voice_prompt_drop_rate,
+        )
+
+    # ======================================================================
+    # CAST TRAINABLE PARAMS TO FP32 (prevents GradScaler issues with fp16)
+    # ======================================================================
+    if getattr(training_args, "fp16", False) or getattr(training_args, "bf16", False):
+        logger.info("Casting trainable parameters to float32 for GradScaler compatibility.")
+        model_ref = surgery_model.module if isinstance(surgery_model, nn.DataParallel) else surgery_model
+        for name, param in model_ref.named_parameters():
+            if param.requires_grad:
+                param.data = param.data.to(torch.float32)
+
+    # ======================================================================
+    # BUILD TRAINER
+    # ======================================================================
+    ema_cb = EmaCallback(attr_path="model.prediction_head", decay=0.999, device="cuda")
+
+    trainer = VibeVoiceSurgeryTrainer(
+        model=surgery_model,
+        args=training_args,
+        train_dataset=train_dataset,
+        eval_dataset=eval_dataset,
+        data_collator=data_collator,
+        callbacks=[
+            ema_cb,
+            LoRADebugCallback(
+                log_every_n_steps=int(getattr(training_args, "logging_steps", 50) or 50)
+            ),
+        ],
+    )
+
+    # ── Debug Save ──
+    if getattr(training_args, "debug_save", False):
+        try:
+            debug_dir = os.path.join(training_args.output_dir, "debug_initial")
+            lora_out = os.path.join(debug_dir, "lora")
+            os.makedirs(lora_out, exist_ok=True)
+            logger.info(f"[debug_save] Saving initial components to {debug_dir}")
+            model_ref = surgery_model.module if isinstance(surgery_model, nn.DataParallel) else surgery_model
+            lm = getattr(model_ref.model, "language_model", None)
+            if hasattr(lm, "save_pretrained"):
+                lm.save_pretrained(lora_out)
+            ph = getattr(model_ref.model, "prediction_head", None)
+            if ph is not None and hasattr(ph, "state_dict"):
+                torch.save(ph.state_dict(), os.path.join(lora_out, "diffusion_head_full.bin"))
+        except Exception as e:
+            logger.warning(f"[debug_save] Failed: {e}")
+
+    # ── Gradient Checkpointing ──
+    if getattr(training_args, "gradient_checkpointing", False):
+        try:
+            model_ref = surgery_model.module if isinstance(surgery_model, nn.DataParallel) else surgery_model
+            model_ref.gradient_checkpointing_enable()
+            logger.info("Gradient checkpointing enabled.")
+        except Exception:
+            logger.warning("Failed to enable gradient checkpointing.")
+
+    # ======================================================================
+    # RESUME FROM CHECKPOINT
+    # ======================================================================
+    if training_args.do_train and training_args.resume_from_checkpoint:
+        checkpoint_path = None
+        if isinstance(training_args.resume_from_checkpoint, bool) and training_args.resume_from_checkpoint:
+            from transformers.trainer_utils import get_last_checkpoint
+            checkpoint_path = get_last_checkpoint(training_args.output_dir)
+        else:
+            checkpoint_path = training_args.resume_from_checkpoint
+
+        if checkpoint_path and os.path.exists(checkpoint_path):
+            lora_dir = os.path.join(checkpoint_path, "lora")
+            if os.path.exists(lora_dir):
+                logger.info(f"Resuming custom weights from {lora_dir}")
+                model_ref = surgery_model.module if isinstance(surgery_model, nn.DataParallel) else surgery_model
+
+                # Load LLM LoRA
+                lm = getattr(model_ref.model, "language_model", None)
+                if hasattr(lm, "save_pretrained"):
+                    try:
+                        from peft import load_peft_weights, set_peft_model_state_dict
+                        adapters_weights = load_peft_weights(lora_dir)
+                        set_peft_model_state_dict(model_ref.model.language_model, adapters_weights)
+                        logger.info("Loaded LLM LoRA weights.")
+                    except Exception as e:
+                        logger.warning(f"Could not load LLM LoRA: {e}")
+
+                # Load Diffusion Head
+                ph_path = os.path.join(lora_dir, "diffusion_head_full.bin")
+                if os.path.exists(ph_path) and hasattr(model_ref.model, "prediction_head"):
+                    try:
+                        model_ref.model.prediction_head.load_state_dict(
+                            torch.load(ph_path, map_location="cpu"), strict=False
+                        )
+                        logger.info("Loaded Diffusion Head weights.")
+                    except Exception as e:
+                        logger.warning(f"Failed to load Diffusion Head: {e}")
+
+                # Load Connectors
+                for conn_name in ["acoustic_connector", "semantic_connector"]:
+                    conn_path = os.path.join(lora_dir, conn_name, "pytorch_model.bin")
+                    conn = getattr(model_ref.model, conn_name, None)
+                    if os.path.exists(conn_path) and conn is not None:
+                        try:
+                            conn.load_state_dict(torch.load(conn_path, map_location="cpu"))
+                            logger.info(f"Loaded {conn_name}.")
+                        except Exception as e:
+                            logger.warning(f"Failed to load {conn_name}: {e}")
+
+                # Load Surgery Module
+                sm_path = os.path.join(lora_dir, "surgery_module", "pytorch_model.bin")
+                sm = getattr(model_ref.model, "surgery_module", None)
+                if os.path.exists(sm_path) and sm is not None:
+                    try:
+                        sm.load_state_dict(torch.load(sm_path, map_location="cpu"))
+                        logger.info("Loaded Surgery Module weights.")
+                    except Exception as e:
+                        logger.warning(f"Failed to load Surgery Module: {e}")
+
+    # ======================================================================
+    # TRAIN
+    # ======================================================================
+    if training_args.do_train:
+        trainer.train(resume_from_checkpoint=False)
+
+        # ── Save Final ──
+        lora_out = os.path.join(training_args.output_dir, "lora")
+        os.makedirs(lora_out, exist_ok=True)
+        model_ref = surgery_model.module if isinstance(surgery_model, nn.DataParallel) else surgery_model
+
+        lm = getattr(model_ref.model, "language_model", None)
+        if hasattr(lm, "save_pretrained"):
+            lm.save_pretrained(lora_out)
+
+        ph = getattr(model_ref.model, "prediction_head", None)
+        if hasattr(ph, "save_pretrained"):
+            ph_dir = os.path.join(lora_out, "diffusion_head")
+            os.makedirs(ph_dir, exist_ok=True)
+            ph.save_pretrained(ph_dir)
+        if ph is not None and hasattr(ph, "state_dict"):
+            torch.save(ph.state_dict(), os.path.join(lora_out, "diffusion_head_full.bin"))
+
+        for conn_name in ["acoustic_connector", "semantic_connector"]:
+            conn = getattr(model_ref.model, conn_name, None)
+            if conn is not None:
+                conn_dir = os.path.join(lora_out, conn_name)
+                os.makedirs(conn_dir, exist_ok=True)
+                torch.save(conn.state_dict(), os.path.join(conn_dir, "pytorch_model.bin"))
+
+        sm = getattr(model_ref.model, "surgery_module", None)
+        if sm is not None:
+            sm_dir = os.path.join(lora_out, "surgery_module")
+            os.makedirs(sm_dir, exist_ok=True)
+            torch.save(sm.state_dict(), os.path.join(sm_dir, "pytorch_model.bin"))
+
+        logger.info(f"All trained components saved to {lora_out}")
+
+    if training_args.do_eval and eval_dataset is not None:
+        trainer.evaluate()
+
+
+if __name__ == "__main__":
+    main()

VibeVoice-tpu/src/finetune_vibevoice_lora105.py

@@ -0,0 +1,1066 @@
+# train_vibevoice_lora.py
+import os
+os.environ["CUDA_VISIBLE_DEVICES"] = "0"
+os.environ["TOKENIZERS_PARALLELISM"] = "false"
+
+import logging
+import os
+from dataclasses import dataclass, field
+from typing import Any, Dict, List, Optional, Tuple
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from datasets import load_dataset, DatasetDict, VerificationMode
+
+from transformers import (
+    HfArgumentParser,
+    Trainer,
+    set_seed,
+    TrainerCallback,
+)
+from transformers import TrainingArguments as HfTrainingArguments
+
+from peft import LoraConfig, get_peft_model, TaskType
+
+from vibevoice.modular.modeling_vibevoice import VibeVoiceForConditionalGeneration
+from vibevoice.modular.configuration_vibevoice import VibeVoiceConfig
+from vibevoice.processor.vibevoice_processor import VibeVoiceProcessor
+
+# Monkey-patch VibeVoiceConfig for Qwen3 support (must run before model loading)
+try:
+    from vibevoice_surgery_colab import _patch_vibevoice_config_for_qwen3
+    _patch_vibevoice_config_for_qwen3()
+except Exception:
+    # Surgery script may not be available; native Qwen3 support in configuration_vibevoice.py
+    pass
+
+from data_vibevoice import VibeVoiceDataset, VibeVoiceCollator
+
+logger = logging.getLogger(__name__)
+
+# ================== SAMPLE CALLBACK UTILS ==================
+
+import copy
+import torch
+from transformers import TrainerCallback
+
+class EmaCallback(TrainerCallback):
+    def __init__(self, attr_path="model.prediction_head", decay=0.999, device="cuda"):
+        """
+        attr_path: where the head lives under self.model (Trainer wraps your VibeVoiceForConditionalGeneration)
+        decay:     EMA decay (0.999 ~ stable, 0.9999 ~ very smooth, slower to adapt)
+        """
+        self.attr_path = attr_path
+        self.decay = float(decay)
+        self.device = torch.device(device)
+        self.shadow = None
+        self._orig = None  # store non-EMA weights when we swap
+
+    def _get_module(self, model):
+        # Resolve dotted path like "model.prediction_head"
+        mod = model
+        for name in self.attr_path.split('.'):
+            mod = getattr(mod, name)
+        return mod
+
+    def on_train_begin(self, args, state, control, model=None, **kwargs):
+        head = self._get_module(model)
+        self.shadow = {k: p.detach().to(self.device).clone()
+                       for k, p in head.state_dict().items()}
+
+    def on_step_end(self, args, state, control, model=None, **kwargs):
+        if self.shadow is None: return
+        head = self._get_module(model)
+        with torch.no_grad():
+            for k, v in head.state_dict().items():
+                self.shadow[k].mul_(self.decay).add_(v.detach().to(self.device), alpha=(1.0 - self.decay))
+
+    # ---- Swap helpers ----
+    def _swap_in_ema(self, model):
+        head = self._get_module(model)
+        self._orig = copy.deepcopy(head.state_dict())
+        head.load_state_dict(self.shadow, strict=False)
+
+    def _swap_back(self, model):
+        if self._orig is None: return
+        head = self._get_module(model)
+        head.load_state_dict(self._orig, strict=False)
+        self._orig = None
+
+    def on_evaluate(self, args, state, control, model=None, **kwargs):
+        # use EMA during eval
+        self._swap_in_ema(model)
+
+    def on_evaluate_end(self, args, state, control, model=None, **kwargs):
+        self._swap_back(model)
+
+    def on_save(self, args, state, control, model=None, **kwargs):
+        # temporarily swap to EMA, let Trainer save, then swap back
+        self._swap_in_ema(model)
+
+    def on_save_end(self, args, state, control, model=None, **kwargs):
+        self._swap_back(model)
+
+    def on_train_end(self, args, state, control, model=None, **kwargs):
+        # final checkpoint: persist EMA
+        self._swap_in_ema(model)
+
+
+@dataclass
+class ModelArguments:
+    model_name_or_path: Optional[str] = field(
+        default=None, metadata={"help": "Path to VibeVoice base model with config.json"}
+    )
+    processor_name_or_path: Optional[str] = field(
+        default=None, metadata={"help": "Path to processor dir (preprocessor_config.json). Defaults to model path."}
+    )
+    cache_dir: Optional[str] = field(default=None)
+    freeze_acoustic_tokenizer: bool = field(default=True)
+    freeze_semantic_tokenizer: bool = field(default=True)
+    lora_r: int = field(default=8)
+    lora_alpha: int = field(default=32)
+    lora_dropout: float = field(default=0.05)
+    lora_target_modules: str = field(
+        default="q_proj,k_proj,v_proj,o_proj,gate_proj,up_proj,down_proj",
+        metadata={"help": "Comma-separated list of target module names in the LLM blocks"},
+    )
+    lora_wrap_diffusion_head: bool = field(default=False, metadata={"help": "Wrap diffusion head with PEFT LoRA"})
+    train_diffusion_head: bool = field(default=False, metadata={"help": "Train diffusion prediction head (full fine-tune)"})
+    train_connectors: bool = field(default=False, metadata={"help": "Train acoustic/semantic connectors (full fine-tune)"})
+    train_surgery_module: bool = field(default=False, metadata={"help": "Train surgery module (full fine-tune, NOT LoRA). For surgery models only."})
+    layers_to_freeze: Optional[str] = field(
+        default=None, 
+        metadata={"help": "Comma-separated indices of diffusion head layers to freeze (e.g., '0,1,5,7,8')."}
+    )
+
+@dataclass
+class DataArguments:
+    dataset_name: Optional[str] = field(default=None, metadata={"help": "HF dataset name or 'json' with --train_jsonl for local files"})
+    dataset_config_name: Optional[str] = field(default=None)
+    train_split_name: str = field(default="train")
+    eval_split_name: Optional[str] = field(default="validation")
+    text_column_name: str = field(default="text")
+    audio_column_name: str = field(default="audio")
+    voice_prompts_column_name: Optional[str] = field(default="voice_prompts")
+    eval_split_size: float = field(default=0.0)
+    ignore_verifications: bool = field(default=False)
+    max_length: Optional[int] = field(default=None)
+    train_jsonl: Optional[str] = field(default=None, metadata={"help": "Path to local train JSONL with {text, audio, [voice_prompts]}"})
+    validation_jsonl: Optional[str] = field(default=None, metadata={"help": "Optional path to local validation JSONL"})
+    voice_prompt_drop_rate: float = field(
+        default=0.0,
+        metadata={"help": "Probability to drop conditioning voice prompt during training (0.0 keep always, 1.0 drop always)."},
+    )
+
+@dataclass
+class CustomTrainingArguments(HfTrainingArguments):
+    ddpm_batch_mul: int = field(default=1)
+    ce_loss_weight: float = field(default=1.0)
+    diffusion_loss_weight: float = field(default=1.0)
+    debug_ce_details: bool = field(default=False)
+    debug_ce_topk: int = field(default=5)
+    debug_ce_max_examples: int = field(default=1)
+    debug_ce_every_n_steps: int = field(default=200)
+    gradient_clipping: bool = field(
+        default=False,
+        metadata={"help": "Enable gradient clipping using max_grad_norm (set via --max_grad_norm, default 1.0). When False, disables clipping by forcing max_grad_norm=0.0."},
+    )
+    debug_save: bool = field(
+        default=False,
+        metadata={"help": "If set, saves model components BEFORE training starts, into output_dir/debug_initial."},
+    )
+
+def build_lora_config(args: ModelArguments) -> LoraConfig:
+    target_modules = [s.strip() for s in args.lora_target_modules.split(",") if s.strip()]
+    return LoraConfig(
+        r=args.lora_r,
+        lora_alpha=args.lora_alpha,
+        lora_dropout=args.lora_dropout,
+        bias="none",
+        task_type=TaskType.CAUSAL_LM,
+        target_modules=target_modules,
+    )
+
+def build_head_lora_config(args: ModelArguments) -> LoraConfig:
+    target_modules = ["noisy_images_proj","cond_proj","gate_proj","up_proj","down_proj","linear"]
+    return LoraConfig(
+        r=args.lora_r,
+        lora_alpha=args.lora_alpha,
+        lora_dropout=args.lora_dropout,
+        bias="none",
+        task_type=TaskType.FEATURE_EXTRACTION,
+        target_modules=target_modules,
+    )
+
+def mask_for_ce(labels: torch.Tensor, attention_mask: torch.Tensor, acoustic_input_mask: torch.Tensor, pad_id: int = -100) -> torch.Tensor:
+    shifted = labels[:, 1:].contiguous()
+    base_mask = attention_mask[:, 1:].contiguous().eq(1) if (attention_mask is not None and attention_mask.numel() > 0) else torch.ones_like(shifted, dtype=torch.bool)
+    label_is_acoustic = acoustic_input_mask[:, 1:].contiguous()
+    final_mask = base_mask & (~label_is_acoustic)
+    out = shifted.clone()
+    out[~final_mask] = pad_id
+    return out
+
+def _patch_acoustic_encode_for_legacy_indexing(model_obj, logger_):
+    try:
+        acoustic = getattr(getattr(model_obj, "model", model_obj), "acoustic_tokenizer", None)
+        if acoustic is None or not hasattr(acoustic, "encode"):
+            logger_.warning("No acoustic_tokenizer.encode() found to patch.")
+            return
+        base_encode = acoustic.encode
+        def encode_wrapped(*args, **kwargs):
+            out = base_encode(*args, **kwargs)
+            try:
+                _ = out[0][0]
+                return out
+            except Exception:
+                pass
+            if isinstance(out, dict):
+                for k in ("frames", "codes", "tokens", "latents", "hidden_states"):
+                    if k in out:
+                        return [[out[k]]]
+                if len(out) > 0:
+                    return [[next(iter(out.values()))]]
+            for attr in ("frames", "codes", "tokens", "latents", "hidden_states"):
+                if hasattr(out, attr):
+                    return [[getattr(out, attr)]]
+            try:
+                if isinstance(out, torch.Tensor):
+                    return [[out]]
+            except Exception:
+                pass
+            return [[out]]
+        acoustic.encode = encode_wrapped
+        logger_.info("Patched acoustic_tokenizer.encode() to return [[...]] for legacy indexing.")
+    except Exception as e:
+        logger_.warning(f"Failed to patch acoustic_tokenizer.encode(): {e}")
+
+def main() -> None:
+    parser = HfArgumentParser((ModelArguments, DataArguments, CustomTrainingArguments))
+    model_args, data_args, training_args = parser.parse_args_into_dataclasses()
+
+    logging.basicConfig(
+        format="%(asctime)s - %(levelname)s - %(name)s - %(message)s",
+        datefmt="%m/%d/%Y %H:%M:%S",
+        level=logging.INFO if training_args.local_rank in [-1, 0] else logging.WARN,
+    )
+    logger.info("Training/evaluation parameters %s", training_args)
+    set_seed(training_args.seed)
+
+    # Configure gradient clipping
+    if not getattr(training_args, "gradient_clipping", False):
+        if hasattr(training_args, "max_grad_norm"):
+            training_args.max_grad_norm = 0.0
+            logger.info("Gradient clipping disabled (set max_grad_norm=0.0). Use --gradient_clipping to enable.")
+    else:
+        if (not hasattr(training_args, "max_grad_norm")) or training_args.max_grad_norm is None or training_args.max_grad_norm <= 0:
+            training_args.max_grad_norm = 1.0
+        logger.info(f"Gradient clipping enabled: max_grad_norm={training_args.max_grad_norm}")
+
+    # Load processor
+    processor_path = model_args.processor_name_or_path or model_args.model_name_or_path
+    if processor_path is None:
+        raise ValueError("--model_name_or_path (or --processor_name_or_path) must be provided")
+    processor: VibeVoiceProcessor = VibeVoiceProcessor.from_pretrained(processor_path)
+
+    # Required special tokens
+    tok = processor.tokenizer
+    for required in ["speech_start_id", "speech_diffusion_id", "speech_end_id"]:
+        if not hasattr(tok, required) or getattr(tok, required) is None:
+            raise RuntimeError(f"Tokenizer missing required special id: {required}")
+
+    # Load model
+    if model_args.model_name_or_path is None:
+        raise ValueError("--model_name_or_path is required to load VibeVoice base model")
+    dtype = torch.float32
+    if training_args.bf16:
+        dtype = torch.bfloat16
+    elif getattr(training_args, "fp16", False):
+        dtype = torch.float16
+    model = VibeVoiceForConditionalGeneration.from_pretrained(
+        model_args.model_name_or_path,
+        torch_dtype=dtype, device_map={"": 0},
+    )
+    _patch_acoustic_encode_for_legacy_indexing(model, logger)
+    processor.semantic_tokenizer = getattr(model.model, "semantic_tokenizer", None)
+
+    # Diagnostics: LM head tie
+    try:
+        in_emb_mod = model.get_input_embeddings()
+        out_emb_mod = model.get_output_embeddings()
+        in_w = getattr(in_emb_mod, "weight", None)
+        out_w = getattr(out_emb_mod, "weight", None)
+        shared_ptr = bool(in_w is not None and out_w is not None and in_w.data_ptr() == out_w.data_ptr())
+        values_equal = False
+        if in_w is not None and out_w is not None and in_w.shape == out_w.shape:
+            try:
+                values_equal = bool(torch.allclose(in_w, out_w))
+            except Exception:
+                values_equal = False
+        try:
+            tie_cfg = getattr(getattr(model.config, "decoder_config", model.config), "tie_word_embeddings", None)
+        except Exception:
+            tie_cfg = getattr(model.config, "tie_word_embeddings", None)
+        logger.info(f"LM head diagnostics -> shared_params={shared_ptr}, values_equal={values_equal}, tie_word_embeddings={tie_cfg}")
+        if out_w is not None:
+            logger.info(f"LM head requires_grad before freeze: {bool(out_w.requires_grad)}")
+    except Exception as e:
+        logger.warning(f"LM head tie diagnostics failed: {e}")
+
+    # Hard-tie LM head
+    try:
+        emb_module = model.get_input_embeddings()
+        head_module = model.get_output_embeddings()
+        if hasattr(emb_module, "weight") and hasattr(head_module, "weight"):
+            if emb_module.weight.shape == head_module.weight.shape and emb_module.weight.data_ptr() != head_module.weight.data_ptr():
+                with torch.no_grad():
+                    head_module.weight = emb_module.weight
+                logger.info("Force-tied LM head weight to input embeddings (pointer share).")
+    except Exception as e:
+        logger.warning(f"Force-tie of LM head failed: {e}")
+
+    # Validate special IDs (info logs only)
+    try:
+        special_names = ["speech_start_id", "speech_diffusion_id", "speech_end_id"]
+        try:
+            vocab_size = int(getattr(model.config.decoder_config, "vocab_size", 0))
+        except Exception:
+            vocab_size = 0
+        in_emb_mod = model.get_input_embeddings()
+        out_emb_mod = model.get_output_embeddings()
+        in_w = getattr(in_emb_mod, "weight", None)
+        out_w = getattr(out_emb_mod, "weight", None)
+        for name in special_names:
+            val = getattr(tok, name, None)
+            exists = (val is not None)
+            in_range = (exists and isinstance(val, int) and 0 <= val < vocab_size)
+            equal_row = None
+            if in_range and in_w is not None and out_w is not None and in_w.shape == out_w.shape and in_w.size(0) > val:
+                try:
+                    equal_row = bool(torch.allclose(in_w[val], out_w[val]))
+                except Exception:
+                    equal_row = False
+            decoded_str = None
+            if exists and isinstance(val, int):
+                try:
+                    decoded_str = tok.decode([val])
+                except Exception:
+                    try:
+                        decoded_str = tok.convert_ids_to_tokens(val)
+                    except Exception:
+                        decoded_str = "<decode_failed>"
+            logger.info(f"Special token check -> {name}={val}, decoded='{decoded_str}', exists={exists}, in_vocab_range={in_range}, emb_vs_head_row_equal={equal_row}")
+    except Exception as e:
+        logger.warning(f"Special token ID/row validation failed: {e}")
+
+    # Quick tokenizer diagnostics (optional)
+    try:
+        logger.info("=== TOKENIZER DIAGNOSTICS ===")
+        logger.info(f"Tokenizer class: {type(tok).__name__}")
+        logger.info(f"Tokenizer vocab_size: {tok.vocab_size}")
+        # tiny CE smoke test
+        with torch.no_grad():
+            simple_text = "The cat sat on the mat."
+            simple_ids = torch.tensor([tok.encode(simple_text, add_special_tokens=True)], device=model.device)
+            simple_mask = torch.ones_like(simple_ids)
+            x = model.get_input_embeddings()(simple_ids)
+            outputs = model.model(inputs_embeds=x, attention_mask=simple_mask, return_dict=True)
+            logits = model.lm_head(outputs.last_hidden_state)
+            shift_logits = logits[:, :-1, :].contiguous()
+            shift_labels = simple_ids[:, 1:].contiguous()
+            ce_loss = F.cross_entropy(shift_logits.view(-1, shift_logits.size(-1)), shift_labels.view(-1), reduction='mean')
+            logger.info(f"Simple text CE loss: {ce_loss.item():.4f}")
+    except Exception as e:
+        logger.warning(f"Tokenizer diagnostics failed: {e}")
+
+    # Disable cache during training
+    if hasattr(model.config, "use_cache") and training_args.do_train:
+        model.config.use_cache = False
+
+    # Freeze tokenizers
+    if model_args.freeze_acoustic_tokenizer and hasattr(model.model, "acoustic_tokenizer"):
+        for p in model.model.acoustic_tokenizer.parameters():
+            p.requires_grad = False
+    if model_args.freeze_semantic_tokenizer and hasattr(model.model, "semantic_tokenizer"):
+        for p in model.model.semantic_tokenizer.parameters():
+            p.requires_grad = False
+
+    # LoRA wrap LLM (optional)
+    lora_cfg = build_lora_config(model_args)
+    tm_lower = [s.strip().lower() for s in model_args.lora_target_modules.split(",") if s.strip()]
+    skip_lm_lora = (len(tm_lower) == 0) or all(t in ("none", "off", "disable", "disabled") for t in tm_lower)
+    if not skip_lm_lora:
+        model.model.language_model = get_peft_model(model.model.language_model, lora_cfg)
+    else:
+        logger.info("Skipping LLM LoRA wrapping (lora_target_modules indicates none).")
+
+    try:
+        model.tie_weights()
+    except Exception:
+        pass
+
+    # Freeze all then enable trainable subsets
+    for _, p in model.named_parameters():
+        p.requires_grad = False
+
+    try:
+        for n, p in model.model.language_model.named_parameters():
+            if "lora_A" in n or "lora_B" in n:
+                p.requires_grad = True
+    except Exception:
+        logger.warning("Could not re-enable LoRA params on language_model.")
+
+    # Diffusion head LoRA wrapping (optional)
+    if getattr(model_args, "lora_wrap_diffusion_head", False) and hasattr(model.model, "prediction_head"):
+        class _HeadForwardShim(nn.Module):
+            def __init__(self, base: nn.Module): super().__init__(); self.base = base
+            def forward(self, *args, **kwargs):
+                if len(args) >= 3:
+                    noisy_images, timesteps, condition = args[:3]
+                else:
+                    noisy_images = kwargs.get("noisy_images")
+                    timesteps = kwargs.get("timesteps")
+                    condition = kwargs.get("condition")
+                return self.base(noisy_images, timesteps, condition)
+        try:
+            shim = _HeadForwardShim(model.model.prediction_head)
+            model.model.prediction_head = get_peft_model(shim, build_head_lora_config(model_args))
+            for n, p in model.model.prediction_head.named_parameters():
+                if "lora_A" in n or "lora_B" in n:
+                    p.requires_grad = True
+        except Exception as e:
+            logger.warning(f"Could not LoRA-wrap diffusion head: {e}")
+
+    # Train full diffusion head (optional)
+    if getattr(model_args, "train_diffusion_head", False) and hasattr(model.model, "prediction_head"):
+        for p in model.model.prediction_head.parameters():
+            p.requires_grad = True
+
+    # Freeze diffusion head layers (optional)
+    if model_args.layers_to_freeze is not None and hasattr(model.model, "prediction_head"):
+        head_params = list(model.model.prediction_head.named_parameters())
+        try:
+            indices_to_freeze = {int(x.strip()) for x in model_args.layers_to_freeze.split(',') if x.strip()}
+            frozen_count = 0
+            for i, (name, param) in enumerate(head_params):
+                if i in indices_to_freeze:
+                    param.requires_grad = False
+                    frozen_count += 1
+                    logger.info(f"Froze layer [{i}]: {name}")
+            logger.info(f"Successfully froze {frozen_count} parameter groups in the diffusion head.")
+        except Exception as e:
+            logger.error(f"Could not parse --layers_to_freeze: {e}")
+            raise
+    
+    # Connectors
+    if getattr(model_args, "train_connectors", False):
+        if hasattr(model.model, "acoustic_connector"):
+            for p in model.model.acoustic_connector.parameters():
+                p.requires_grad = True
+        if hasattr(model.model, "semantic_connector"):
+            for p in model.model.semantic_connector.parameters():
+                p.requires_grad = True
+    else:
+        if hasattr(model.model, "acoustic_connector"):
+            for p in model.model.acoustic_connector.parameters():
+                p.requires_grad = False
+        if hasattr(model.model, "semantic_connector"):
+            for p in model.model.semantic_connector.parameters():
+                p.requires_grad = False
+
+    # Surgery Module — full fine-tune (NOT LoRA)
+    # This is for models that underwent surgery (Qwen3 replacement).
+    # The surgery module bridges Qwen3 hidden_size (2560) to diffusion head (3584).
+    if getattr(model_args, "train_surgery_module", False) and hasattr(model.model, "surgery_module"):
+        for p in model.model.surgery_module.parameters():
+            p.requires_grad = True
+        logger.info("Surgery Module enabled for full fine-tuning (all parameters trainable).")
+    elif hasattr(model.model, "surgery_module"):
+        # Keep surgery module frozen unless explicitly requested
+        for p in model.model.surgery_module.parameters():
+            p.requires_grad = False
+
+    # Freeze embedding + head
+    try:
+        emb = model.get_input_embeddings()
+        if hasattr(emb, "weight"):
+            emb.weight.requires_grad_(False)
+        head = model.get_output_embeddings()
+        if head is not None and hasattr(head, "weight"):
+            head.weight.requires_grad_(False)
+    except Exception:
+        pass
+
+    # Diagnostics
+    def _sum_params(named_iter):
+        return sum(p.numel() for _, p in named_iter if p.requires_grad)
+    try:
+        lm_lora = _sum_params(model.model.language_model.named_parameters()) if hasattr(model.model, "language_model") else 0
+        pred_head_train = _sum_params(model.model.prediction_head.named_parameters()) if hasattr(model.model, "prediction_head") else 0
+        ac_conn_train = _sum_params(model.model.acoustic_connector.named_parameters()) if hasattr(model.model, "acoustic_connector") else 0
+        se_conn_train = _sum_params(model.model.semantic_connector.named_parameters()) if hasattr(model.model, "semantic_connector") else 0
+        surgery_train = _sum_params(model.model.surgery_module.named_parameters()) if hasattr(model.model, "surgery_module") else 0
+        total_trainable = sum(p.numel() for p in model.parameters() if p.requires_grad)
+        logger.info(f"Trainable by block -> LLM-LoRA: {lm_lora:,} | diff_head: {pred_head_train:,} | ac_conn: {ac_conn_train:,} | se_conn: {se_conn_train:,} | surgery: {surgery_train:,}")
+        logger.info("TOTAL trainable: %s", f"{total_trainable:,}")
+    except Exception:
+        pass
+
+    # Preprocessed data classes
+    class PreprocessedBatchDataset:
+        def __init__(self, preprocessed_file: str):
+            self.data = torch.load(preprocessed_file, map_location='cpu')
+            logger.info(f"Loaded {len(self.data)} preprocessed batches from {preprocessed_file}")
+        
+        def __len__(self):
+            return len(self.data)
+        
+        def __getitem__(self, idx):
+            batch = self.data[idx]
+            result = {}
+            for k, v in batch.items():
+                if isinstance(v, torch.Tensor):
+                    result[k] = v
+                else:
+                    result[k] = v
+            return result
+
+    class PreprocessedBatchSubset:
+        def __init__(self, dataset: 'PreprocessedBatchDataset', indices: List[int]):
+            self.dataset = dataset
+            self.indices = indices
+        
+        def __len__(self):
+            return len(self.indices)
+        
+        def __getitem__(self, idx):
+            actual_idx = self.indices[idx]
+            return self.dataset[actual_idx]
+
+    class PreprocessedBatchCollator:
+        def __call__(self, batch: List[Dict[str, torch.Tensor]]) -> Dict[str, torch.Tensor]:
+            if not batch:
+                return {}
+            result = {}
+            for key in batch[0].keys():
+                tensors = [b[key] for b in batch if b[key] is not None]
+                if tensors and isinstance(tensors[0], torch.Tensor):
+                    result[key] = torch.cat(tensors, dim=0)
+                else:
+                    result[key] = tensors[0] if tensors else None
+            return result
+
+    # Datasets
+    preprocessed_dir = os.path.join(training_args.output_dir, "preprocessed")
+    preprocessed_file = os.path.join(preprocessed_dir, "preprocessed_batches.pt")
+    
+    if os.path.exists(preprocessed_file):
+        logger.info(f"Loading preprocessed data from {preprocessed_file}")
+        preprocessed_data = PreprocessedBatchDataset(preprocessed_file)
+        
+        train_dataset = preprocessed_data
+        eval_dataset = None
+        
+        if training_args.do_eval and data_args.eval_split_size and data_args.eval_split_size > 0 and len(preprocessed_data) > 1:
+            num_eval = max(1, int(len(preprocessed_data) * data_args.eval_split_size))
+            num_train = len(preprocessed_data) - num_eval
+            indices = list(range(len(preprocessed_data)))
+            import random
+            random.Random(training_args.seed).shuffle(indices)
+            train_indices = indices[:num_train]
+            eval_indices = indices[num_train:]
+            train_dataset = PreprocessedBatchSubset(preprocessed_data, train_indices)
+            eval_dataset = PreprocessedBatchSubset(preprocessed_data, eval_indices)
+    else:
+        logger.info(f"Preprocessed data not found at {preprocessed_file}, loading from raw JSONL/HF datasets")
+        verification_mode = VerificationMode.NO_CHECKS if data_args.ignore_verifications else VerificationMode.BASIC_CHECKS
+        if data_args.train_jsonl is not None:
+            data_files: Dict[str, str] = {"train": data_args.train_jsonl}
+            if data_args.validation_jsonl is not None:
+                data_files["validation"] = data_args.validation_jsonl
+            raw = load_dataset("json", data_files=data_files, verification_mode=verification_mode, cache_dir=model_args.cache_dir)
+        else:
+            if data_args.dataset_name is None:
+                raise ValueError("Provide --dataset_name (HF datasets) or use --train_jsonl/--validation_jsonl for local files.")
+            raw = load_dataset(
+                data_args.dataset_name,
+                data_args.dataset_config_name,
+                verification_mode=verification_mode,
+                cache_dir=model_args.cache_dir,
+            )
+        train_ds = raw[data_args.train_split_name]
+        eval_ds = None
+        if training_args.do_eval:
+            if data_args.eval_split_name and data_args.eval_split_name in raw:
+                eval_ds = raw[data_args.eval_split_name]
+            elif data_args.eval_split_size and data_args.eval_split_size > 0 and len(train_ds) > 1:
+                split = train_ds.train_test_split(test_size=data_args.eval_split_size, seed=training_args.seed)
+                train_ds, eval_ds = split["train"], split["test"]
+
+        train_dataset = VibeVoiceDataset(
+            train_ds,
+            text_column=data_args.text_column_name,
+            audio_column=data_args.audio_column_name,
+            voice_prompts_column=data_args.voice_prompts_column_name,
+        )
+        eval_dataset = None
+        if eval_ds is not None:
+            eval_dataset = VibeVoiceDataset(
+                eval_ds,
+                text_column=data_args.text_column_name,
+                audio_column=data_args.audio_column_name,
+                voice_prompts_column=data_args.voice_prompts_column_name,
+            )
+
+    # Ratios/dims from processor+model
+    speech_compress_ratio = getattr(processor, "speech_tok_compress_ratio", 3200)
+    semantic_dim = getattr(model.config, "semantic_vae_dim", None)
+    if semantic_dim is None:
+        try:
+            semantic_dim = int(getattr(model.config.semantic_tokenizer_config, "vae_dim", 128))
+        except Exception:
+            semantic_dim = 128
+
+    compute_semantics_flag = hasattr(processor, "semantic_tokenizer") and processor.semantic_tokenizer is not None
+
+    if os.path.exists(preprocessed_file):
+        data_collator = PreprocessedBatchCollator()
+    else:
+        data_collator = VibeVoiceCollator(
+            processor=processor,
+            max_length=data_args.max_length,
+            speech_compress_ratio=speech_compress_ratio,
+            semantic_vae_dim=semantic_dim,
+            compute_semantics=compute_semantics_flag,
+            debug_checks=False,
+            voice_prompt_drop_rate=data_args.voice_prompt_drop_rate,
+        )
+
+    class LoRADebugCallback(TrainerCallback):
+        def __init__(self, log_every_n_steps: int = 50):
+            self.log_every_n_steps = max(1, int(log_every_n_steps))
+            self.prev_param_norms: Dict[str, float] = {}
+            self.lora_param_names: List[str] = []
+
+        def on_train_begin(self, args, state, control, model=None, **kwargs):
+            try:
+                if model is None:
+                    return
+                named: Dict[str, torch.nn.Parameter] = dict(model.named_parameters())
+                self.lora_param_names = [n for n in named.keys() if ("lora_A" in n or "lora_B" in n)]
+                for n in self.lora_param_names:
+                    p = named[n]
+                    self.prev_param_norms[n] = float(p.data.norm().item())
+                total = len(self.lora_param_names)
+                req_grad = sum(1 for n in self.lora_param_names if named[n].requires_grad)
+                num_A = sum(1 for n in self.lora_param_names if "lora_A" in n)
+                num_B = sum(1 for n in self.lora_param_names if "lora_B" in n)
+                zero_B = sum(1 for n in self.lora_param_names if ("lora_B" in n and float(named[n].data.norm().item()) == 0.0))
+                logger.info(f"LoRA debug: found {total} LoRA params (A={num_A}, B={num_B}); trainable={req_grad}. Initial lora_B_zero={zero_B}.")
+                if total == 0:
+                    logger.warning("LoRA debug: No LoRA parameters found. Check lora_target_modules.")
+                if req_grad != total:
+                    logger.warning("LoRA debug: Some LoRA params are frozen. They should be trainable.")
+            except Exception as e:
+                logger.warning(f"LoRA debug (on_train_begin) failed: {e}")
+
+        def on_step_end(self, args, state, control, model=None, **kwargs):
+            try:
+                if model is None or len(self.lora_param_names) == 0:
+                    return
+                step = int(getattr(state, "global_step", 0) or 0)
+                if step % self.log_every_n_steps != 0 and step != 1:
+                    return
+                named: Dict[str, torch.nn.Parameter] = dict(model.named_parameters())
+                changed_A = 0
+                changed_B = 0
+                zero_B = 0
+                eps = 1e-12
+                for n in self.lora_param_names:
+                    p = named.get(n, None)
+                    if p is None:
+                        continue
+                    prev = self.prev_param_norms.get(n, 0.0)
+                    curr = float(p.data.norm().item())
+                    if "lora_A" in n and abs(curr - prev) > eps:
+                        changed_A += 1
+                    if "lora_B" in n:
+                        if abs(curr - prev) > eps:
+                            changed_B += 1
+                        if curr == 0.0:
+                            zero_B += 1
+                    self.prev_param_norms[n] = curr
+                total_A = sum(1 for n in self.lora_param_names if "lora_A" in n)
+                total_B = sum(1 for n in self.lora_param_names if "lora_B" in n)
+                logger.info(f"LoRA debug step {step}: changed A {changed_A}/{total_A}, changed B {changed_B}/{total_B}, lora_B_zero_now={zero_B}.")
+            except Exception as e:
+                logger.warning(f"LoRA debug (on_step_end) failed: {e}")
+
+    class VibeVoiceTrainer(Trainer):
+        def compute_loss(self, model: VibeVoiceForConditionalGeneration, inputs: Dict[str, Any], return_outputs=False, num_items_in_batch: Optional[int] = None):
+            labels = inputs.get("input_ids")
+            attention_mask = inputs.get("attention_mask")
+            acoustic_input_mask = inputs.get("acoustic_input_mask")
+
+            # Ensure semantic tensors exist and have correct dtype/device
+            sem = inputs.get("speech_semantic_tensors", None)
+            try:
+                target_dtype = next(model.model.semantic_connector.parameters()).dtype
+            except Exception:
+                target_dtype = model.get_input_embeddings().weight.dtype
+
+            if sem is None:
+                sm = inputs.get("speech_masks")
+                if sm is not None:
+                    zeros = torch.zeros(
+                        sm.size(0), sm.size(1),
+                        getattr(model.config, "semantic_vae_dim", 128),
+                        dtype=target_dtype,
+                        device=sm.device,
+                    )
+                    inputs["speech_semantic_tensors"] = zeros
+            else:
+                if isinstance(sem, torch.Tensor):
+                    inputs["speech_semantic_tensors"] = sem.to(dtype=target_dtype)
+
+            outputs = model(
+                input_ids=inputs.get("input_ids"),
+                attention_mask=attention_mask,
+                speech_tensors=inputs.get("speech_tensors"),
+                speech_masks=inputs.get("speech_masks"),
+                speech_semantic_tensors=inputs.get("speech_semantic_tensors"),
+                acoustic_input_mask=acoustic_input_mask,
+                acoustic_loss_mask=inputs.get("acoustic_loss_mask"),
+                speeches_loss_input=inputs.get("speeches_loss_input"),
+                ddpm_batch_mul=training_args.ddpm_batch_mul,
+            )
+
+            # Invariants: token/latent selection equality across views (warn, don't assert)
+            try:
+                al_mask = inputs.get("acoustic_loss_mask")
+                sp_masks = inputs.get("speech_masks")
+                sp_loss_sel = inputs.get("speeches_loss_input")
+                num_tok_total = int(acoustic_input_mask.sum().item()) if acoustic_input_mask is not None else 0
+                num_tok_loss = int(al_mask.sum().item()) if al_mask is not None else 0
+                num_lat_total = int(sp_masks.sum().item()) if sp_masks is not None else 0
+                num_lat_loss = int(((sp_loss_sel & sp_masks).sum().item())) if (sp_loss_sel is not None and sp_masks is not None) else 0
+                self.log({
+                    "debug/num_tok_total": float(num_tok_total),
+                    "debug/num_tok_loss": float(num_tok_loss),
+                    "debug/num_lat_total": float(num_lat_total),
+                    "debug/num_lat_loss": float(num_lat_loss),
+                })
+                if sp_loss_sel is not None and sp_masks is not None and al_mask is not None:
+                    if num_tok_loss != num_lat_loss:
+                        logger.warning(f"Loss selection mismatch: acoustic_loss_mask={num_tok_loss} vs speeches_loss_input={num_lat_loss}")
+            except Exception:
+                pass
+
+            # CE Loss
+            logits = outputs.logits
+            ce_labels = mask_for_ce(labels, attention_mask, acoustic_input_mask, pad_id=-100)
+            shift_logits = logits[:, :-1, :].contiguous()
+            loss_fct = nn.CrossEntropyLoss(ignore_index=-100)
+            ce_loss = loss_fct(shift_logits.view(-1, shift_logits.size(-1)), ce_labels.view(-1))
+
+            # Optional CE diagnostics
+            try:
+                self._debug_ce(shift_logits, ce_labels, attention_mask, acoustic_input_mask)
+            except Exception as e:
+                logger.warning(f"Failed invoking CE debug: {e}")
+
+            # Diffusion loss
+            diffusion_loss = outputs.diffusion_loss if outputs.diffusion_loss is not None else torch.tensor(0.0, device=ce_loss.device)
+            total = training_args.ce_loss_weight * ce_loss + training_args.diffusion_loss_weight * diffusion_loss
+
+            # Logs
+            try:
+                prefix = "train" if model.training else "eval"
+                self.log({
+                    f"{prefix}/ce_loss": ce_loss.detach().item(),
+                    f"{prefix}/diffusion_loss": diffusion_loss.detach().item() if isinstance(diffusion_loss, torch.Tensor) else float(diffusion_loss),
+                })
+                if hasattr(self, "optimizer") and self.optimizer is not None and len(self.optimizer.param_groups) > 0:
+                    lr_val = self.optimizer.param_groups[0].get("lr", None)
+                    if lr_val is not None:
+                        self.log({"train/learning_rate_real": float(lr_val)})
+            except Exception:
+                pass
+
+            return (total, outputs) if return_outputs else total
+
+        def _debug_ce(self, shift_logits: torch.Tensor, ce_labels: torch.Tensor, attention_mask: Optional[torch.Tensor], acoustic_input_mask: Optional[torch.Tensor]):
+            try:
+                if not getattr(training_args, "debug_ce_details", False):
+                    return
+                step = int(getattr(self.state, "global_step", 0) or 0)
+                every_n = max(1, int(getattr(training_args, "debug_ce_every_n_steps", 200) or 200))
+                if not (step <= 1 or (step % every_n == 0)):
+                    return
+
+                with torch.no_grad():
+                    vocab = shift_logits.size(-1)
+                    per_token_loss = F.cross_entropy(
+                        shift_logits.view(-1, vocab),
+                        ce_labels.view(-1),
+                        reduction="none",
+                        ignore_index=-100,
+                    ).view_as(ce_labels)
+
+                    valid_mask = ce_labels.ne(-100)
+                    num_valid = int(valid_mask.sum().item())
+                    avg_loss = float((per_token_loss[valid_mask].mean().item())) if num_valid > 0 else float("nan")
+
+                    per_ex_avgs = []
+                    max_examples = max(1, int(getattr(training_args, "debug_ce_max_examples", 1) or 1))
+                    B = ce_labels.size(0)
+                    for b in range(min(B, max_examples)):
+                        vb = valid_mask[b]
+                        if int(vb.sum().item()) > 0:
+                            per_ex_avgs.append(float(per_token_loss[b][vb].mean().item()))
+                        else:
+                            per_ex_avgs.append(float("nan"))
+                    logger.info(f"CE debug: tokens_in_loss={num_valid}, avg_loss={avg_loss:.4f}, per_example_avgs={[round(x,4) if x==x else None for x in per_ex_avgs]}")
+            except Exception as e:
+                logger.warning(f"CE detailed debug failed: {e}")
+
+        # --------- CRITICAL SAVE OVERRIDES: also dump FULL head/connectors for inference ---------
+  
+
+        def _save(self, output_dir: Optional[str] = None, state_dict=None) -> None:
+            try:
+                target_dir = output_dir or self.args.output_dir
+                lora_out = os.path.join(target_dir, "lora")
+                os.makedirs(lora_out, exist_ok=True)
+    
+                # --- LLM PEFT adapters (if LoRA-wrapped) ---
+                language_model = getattr(self.model.model, "language_model", None)
+                if hasattr(language_model, "save_pretrained"):
+                    language_model.save_pretrained(lora_out)
+    
+                # --- Diffusion head PEFT adapters (if LoRA-wrapped) ---
+                pred_head = getattr(self.model.model, "prediction_head", None)
+                if hasattr(pred_head, "save_pretrained"):
+                    ph_dir = os.path.join(lora_out, "diffusion_head")
+                    os.makedirs(ph_dir, exist_ok=True)
+                    pred_head.save_pretrained(ph_dir)
+    
+                # --- ALWAYS save FULL diffusion head state_dict for fallback ---
+                if pred_head is not None and hasattr(pred_head, "state_dict"):
+                    sd = pred_head.state_dict()
+                    torch.save(sd, os.path.join(lora_out, "diffusion_head_full.bin"))
+                    ph_dir = os.path.join(lora_out, "diffusion_head")
+                    os.makedirs(ph_dir, exist_ok=True)
+                    torch.save(sd, os.path.join(ph_dir, "diffusion_head_full.bin"))
+    
+                # --- Connectors (plain state_dicts) ---
+                ac = getattr(self.model.model, "acoustic_connector", None)
+                if ac is not None:
+                    ac_dir = os.path.join(lora_out, "acoustic_connector")
+                    os.makedirs(ac_dir, exist_ok=True)
+                    torch.save(ac.state_dict(), os.path.join(ac_dir, "pytorch_model.bin"))
+    
+                se = getattr(self.model.model, "semantic_connector", None)
+                if se is not None:
+                    se_dir = os.path.join(lora_out, "semantic_connector")
+                    os.makedirs(se_dir, exist_ok=True)
+                    torch.save(se.state_dict(), os.path.join(se_dir, "pytorch_model.bin"))
+    
+            except Exception as e:
+                logger.warning(f"Failed to save LoRA assets: {e}")
+
+
+    # ------------- Build the Trainer -------------
+
+    # Resolve which adapters to apply in samples
+
+    ema_cb = EmaCallback(attr_path="model.prediction_head", decay=0.999, device="cuda")
+
+    # --- CRITICAL FIX: CAST TRAINABLE PARAMS TO FP32 ---
+    # This prevents 'ValueError: Attempting to unscale FP16 gradients'
+    if getattr(training_args, 'fp16', False) or getattr(training_args, 'bf16', False):
+        print('>>> INFO: Enforcing float32 for trainable parameters (LoRA/Head) to fix GradScaler.')
+        for name, param in model.named_parameters():
+            if param.requires_grad:
+                param.data = param.data.to(torch.float32)
+    # ---------------------------------------------------
+
+    trainer = VibeVoiceTrainer(
+        model=model,
+        args=training_args,
+        train_dataset=train_dataset,
+        eval_dataset=eval_dataset,
+        data_collator=data_collator,
+        callbacks=[ema_cb, LoRADebugCallback(log_every_n_steps=(int(getattr(training_args, "logging_steps", 50) or 50)))],
+    )
+
+    # Optional debug pre-training save
+    if getattr(training_args, "debug_save", False):
+        try:
+            debug_dir = os.path.join(training_args.output_dir, "debug_initial")
+            lora_out = os.path.join(debug_dir, "lora")
+            os.makedirs(lora_out, exist_ok=True)
+            logger.info(f"[debug_save] Saving initial (pre-training) model components to: {debug_dir}")
+            # language model adapters / base
+            try:
+                if hasattr(model.model.language_model, "save_pretrained"):
+                    model.model.language_model.save_pretrained(lora_out)
+            except Exception as e_lm:
+                logger.warning(f"[debug_save] Failed to save language_model: {e_lm}")
+            # diffusion head
+            try:
+                if hasattr(model.model, "prediction_head") and hasattr(model.model.prediction_head, "save_pretrained"):
+                    model.model.prediction_head.save_pretrained(os.path.join(lora_out, "diffusion_head"))
+            except Exception as e_head:
+                logger.warning(f"[debug_save] Failed to save prediction_head: {e_head}")
+            # NEW: full diffusion head state_dict as fallback
+            try:
+                ph = getattr(model.model, "prediction_head", None)
+                if ph is not None and hasattr(ph, "state_dict"):
+                    sd = ph.state_dict()
+                    torch.save(sd, os.path.join(lora_out, "diffusion_head_full.bin"))
+                    os.makedirs(os.path.join(lora_out, "diffusion_head"), exist_ok=True)
+                    torch.save(sd, os.path.join(lora_out, "diffusion_head", "diffusion_head_full.bin"))
+            except Exception as e:
+                logger.warning(f"[debug_save] Failed to save FULL diffusion head: {e}")
+            # connectors
+            try:
+                ac_conn = getattr(model.model, "acoustic_connector", None)
+                if ac_conn is not None:
+                    ac_dir = os.path.join(lora_out, "acoustic_connector")
+                    os.makedirs(ac_dir, exist_ok=True)
+                    torch.save(ac_conn.state_dict(), os.path.join(ac_dir, "pytorch_model.bin"))
+            except Exception as e_ac:
+                logger.warning(f"[debug_save] Failed to save acoustic_connector: {e_ac}")
+            try:
+                se_conn = getattr(model.model, "semantic_connector", None)
+                if se_conn is not None:
+                    se_dir = os.path.join(lora_out, "semantic_connector")
+                    os.makedirs(se_dir, exist_ok=True)
+                    torch.save(se_conn.state_dict(), os.path.join(se_dir, "pytorch_model.bin"))
+            except Exception as e_se:
+                logger.warning(f"[debug_save] Failed to save semantic_connector: {e_se}")
+        except Exception as e:
+            logger.warning(f"[debug_save] Unexpected failure saving initial components: {e}")
+
+    if getattr(training_args, "gradient_checkpointing", False):
+        try:
+            model.gradient_checkpointing_enable()
+        except Exception:
+            logger.warning("Failed to enable gradient checkpointing on the model.")
+
+    # =========================================================================
+    # Load Custom Weights from Checkpoint before resuming training
+    # =========================================================================
+    if training_args.do_train and training_args.resume_from_checkpoint:
+        checkpoint_path = None
+        if isinstance(training_args.resume_from_checkpoint, bool) and training_args.resume_from_checkpoint:
+            from transformers.trainer_utils import get_last_checkpoint
+            checkpoint_path = get_last_checkpoint(training_args.output_dir)
+        else:
+            checkpoint_path = training_args.resume_from_checkpoint
+
+        if checkpoint_path is not None and os.path.exists(checkpoint_path):
+            lora_dir = os.path.join(checkpoint_path, "lora")
+            if os.path.exists(lora_dir):
+                logger.info(f"*** Resuming custom weights (LoRA, Connectors, Head) from {lora_dir} ***")
+                
+                # 1. Load LLM LoRA
+                if hasattr(model.model, "language_model"):
+                    try:
+                        from peft import load_peft_weights, set_peft_model_state_dict
+                        adapters_weights = load_peft_weights(lora_dir)
+                        set_peft_model_state_dict(model.model.language_model, adapters_weights)
+                        logger.info("Successfully loaded LLM LoRA weights.")
+                    except Exception as e:
+                        logger.warning(f"Could not load LLM LoRA weights: {e}")
+
+                # 2. Load Diffusion Head
+                ph_full_path = os.path.join(lora_dir, "diffusion_head_full.bin")
+                if os.path.exists(ph_full_path) and hasattr(model.model, "prediction_head"):
+                    try:
+                        model.model.prediction_head.load_state_dict(torch.load(ph_full_path, map_location="cpu"), strict=False)
+                        logger.info("Successfully loaded Diffusion Head weights.")
+                    except Exception as e:
+                        logger.warning(f"Failed to load Diffusion Head weights: {e}")
+
+                # 3. Load Acoustic Connector
+                ac_path = os.path.join(lora_dir, "acoustic_connector", "pytorch_model.bin")
+                if os.path.exists(ac_path) and hasattr(model.model, "acoustic_connector"):
+                    try:
+                        model.model.acoustic_connector.load_state_dict(torch.load(ac_path, map_location="cpu"))
+                        logger.info("Successfully loaded Acoustic Connector weights.")
+                    except Exception as e:
+                        logger.warning(f"Failed to load Acoustic Connector weights: {e}")
+
+                # 4. Load Semantic Connector
+                se_path = os.path.join(lora_dir, "semantic_connector", "pytorch_model.bin")
+                if os.path.exists(se_path) and hasattr(model.model, "semantic_connector"):
+                    try:
+                        model.model.semantic_connector.load_state_dict(torch.load(se_path, map_location="cpu"))
+                        logger.info("Successfully loaded Semantic Connector weights.")
+                    except Exception as e:
+                        logger.warning(f"Failed to load Semantic Connector weights: {e}")
+            else:
+                logger.warning(f"No custom 'lora' directory found inside checkpoint: {checkpoint_path}")
+    # =========================================================================
+
+    if training_args.do_train:
+        # ----- THE FIX: SET resume_from_checkpoint=False HERE -----
+        # The weights are ALREADY loaded via the custom block above.
+        # Setting this to False forces Trainer to start counting steps/epochs from 0
+        # for your new dataset, preventing it from immediately exiting.
+        trainer.train(resume_from_checkpoint=False)
+    
+        lora_out = os.path.join(training_args.output_dir, "lora")
+        os.makedirs(lora_out, exist_ok=True)
+    
+        # LLM PEFT (if any)
+        lm = getattr(model.model, "language_model", None)
+        if hasattr(lm, "save_pretrained"):
+            lm.save_pretrained(lora_out)
+    
+        # Diffusion head PEFT (if any)
+        ph = getattr(model.model, "prediction_head", None)
+        if hasattr(ph, "save_pretrained"):
+            ph_dir = os.path.join(lora_out, "diffusion_head")
+            os.makedirs(ph_dir, exist_ok=True)
+            ph.save_pretrained(ph_dir)
+    
+        # ALWAYS: full diffusion head state_dict fallback
+        try:
+            if ph is not None and hasattr(ph, "state_dict"):
+                sd = ph.state_dict()
+                torch.save(sd, os.path.join(lora_out, "diffusion_head_full.bin"))
+                ph_dir = os.path.join(lora_out, "diffusion_head")
+                os.makedirs(ph_dir, exist_ok=True)
+                torch.save(sd, os.path.join(ph_dir, "diffusion_head_full.bin"))
+        except Exception as e:
+            logger.warning(f"Failed to save FULL diffusion head at end: {e}")
+    
+        # Connectors (if trained)
+        try:
+            ac = getattr(model.model, "acoustic_connector", None)
+            if ac is not None:
+                ac_dir = os.path.join(lora_out, "acoustic_connector")
+                os.makedirs(ac_dir, exist_ok=True)
+                torch.save(ac.state_dict(), os.path.join(ac_dir, "pytorch_model.bin"))
+        except Exception as e:
+            logger.warning(f"Failed to save acoustic_connector: {e}")
+    
+        try:
+            se = getattr(model.model, "semantic_connector", None)
+            if se is not None:
+                se_dir = os.path.join(lora_out, "semantic_connector")
+                os.makedirs(se_dir, exist_ok=True)
+                torch.save(se.state_dict(), os.path.join(se_dir, "pytorch_model.bin"))
+        except Exception as e:
+            logger.warning(f"Failed to save semantic_connector: {e}")
+
+    if training_args.do_eval and eval_dataset is not None:
+        trainer.evaluate()
+
+
+if __name__ == "__main__":
+    main()

VibeVoice-tpu/src/finetune_vibevoice_tpu.py

@@ -0,0 +1,1638 @@
+"""
+VibeVoice Fine-Tuning on TPU v5e-8
+====================================
+
+Complete fine-tuning pipeline for VibeVoice (with surgery module support)
+on Google Cloud TPU v5e-8 (8 chips × 16 GB HBM = 128 GB total).
+
+Key changes from GPU (T4/A100) version:
+  - PyTorch/XLA instead of CUDA
+  - bfloat16 precision (native on TPU v5e)
+  - Custom training loop (HF Trainer lacks native TPU/XLA support)
+  - XLA graph compilation with explicit mark_step() synchronization
+  - MpDeviceLoader for distributed data loading across 8 TPU chips
+  - Gradient accumulation with proper XLA all-reduce
+
+Data:
+  - Expects preprocessed .pt files in an input folder
+  - Each .pt file contains a list of preprocessed batch dicts
+  - Dicts have keys: input_ids, attention_mask, speech_tensors, speech_masks,
+    speech_semantic_tensors, acoustic_input_mask, acoustic_loss_mask, speeches_loss_input
+
+Usage:
+  python finetune_vibevoice_tpu.py \
+    --model_name_or_path /path/to/surgery_model \
+    --preprocessed_dir /path/to/preprocessed_data \
+    --output_dir /path/to/output \
+    --max_steps 5000 \
+    --learning_rate 2e-5 \
+    --gradient_accumulation_steps 8
+"""
+
+import os
+import sys
+import gc
+import copy
+import math
+import time
+import random
+import logging
+import functools
+from dataclasses import dataclass, field
+from typing import Any, Dict, List, Optional, Tuple
+
+# ============================================================================
+# TPU Environment Setup (must be before torch import)
+# ============================================================================
+from tpu_config import setup_tpu_env, TPU_CONFIG, TPU_TRAINING_CONFIG, XLA_CONFIG
+setup_tpu_env()
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+# PyTorch/XLA imports
+import torch_xla
+import torch_xla.core.xla_model as xm
+import torch_xla.core.xla_env_registry as xenv
+import torch_xla.distributed.xla_multiprocessing as xmp
+import torch_xla.distributed.parallel_loader as pl
+from torch_xla.amp import autocast
+
+# Transformers & PEFT
+from transformers import (
+    AutoModel,
+    AutoModelForCausalLM,
+    set_seed,
+)
+from transformers.models.llama.modeling_llama import LlamaRMSNorm
+from peft import LoraConfig, get_peft_model, TaskType
+
+# VibeVoice imports
+from vibevoice.modular.modeling_vibevoice import (
+    VibeVoiceModel,
+    VibeVoiceForConditionalGeneration,
+    SpeechConnector,
+)
+from vibevoice.modular.configuration_vibevoice import VibeVoiceConfig
+from vibevoice.processor.vibevoice_processor import VibeVoiceProcessor
+
+# Surgery imports — monkey-patch for Qwen3 support
+try:
+    from vibevoice_surgery_colab import (
+        _patch_vibevoice_config_for_qwen3,
+        Qwen3SurgeryModule,
+        load_surgery_model,
+        QWEN3_HIDDEN_SIZE,
+        DIFFUSION_HIDDEN_SIZE,
+        SURGERY_LAYER_INDICES,
+    )
+    _patch_vibevoice_config_for_qwen3()
+except ImportError:
+    try:
+        from vibevoice_surgery_colab import _patch_vibevoice_config_for_qwen3
+        _patch_vibevoice_config_for_qwen3()
+        HAS_SURGERY = False
+    except Exception:
+        HAS_SURGERY = False
+
+logger = logging.getLogger(__name__)
+
+
+# ============================================================================
+# SECTION 1: Argument Dataclasses
+# ============================================================================
+
+@dataclass
+class TPUModelArguments:
+    """Arguments for model loading on TPU."""
+    model_name_or_path: str = field(
+        metadata={"help": "Path to the VibeVoice/surgery model directory"}
+    )
+    processor_name_or_path: Optional[str] = field(
+        default=None,
+        metadata={"help": "Path to processor dir. Defaults to model_name_or_path."},
+    )
+
+    # Freezing strategy
+    freeze_llm: bool = field(default=False)
+    freeze_diffusion_head: bool = field(default=True)
+    freeze_surgery_module: bool = field(default=False)
+    freeze_connectors: bool = field(default=False)
+    freeze_acoustic_tokenizer: bool = field(default=True)
+    freeze_semantic_tokenizer: bool = field(default=True)
+    freeze_lm_head: bool = field(default=True)
+
+    # LoRA
+    lora_r: int = field(default=8)
+    lora_alpha: int = field(default=32)
+    lora_dropout: float = field(default=0.05)
+    lora_target_modules: str = field(
+        default="q_proj,k_proj,v_proj,o_proj,gate_proj,up_proj,down_proj",
+    )
+    lora_wrap_diffusion_head: bool = field(default=False)
+
+    # Fine-tune flags
+    train_diffusion_head: bool = field(default=False)
+    train_connectors: bool = field(default=True)
+    train_surgery_module: bool = field(default=True)
+
+    # Advanced
+    layers_to_freeze: Optional[str] = field(default=None)
+
+
+@dataclass
+class TPUDataArguments:
+    """Arguments for data loading."""
+    preprocessed_dir: str = field(
+        metadata={"help": "Directory containing preprocessed .pt files"}
+    )
+    eval_split_size: float = field(default=0.05)
+    seed: int = field(default=42)
+
+
+@dataclass
+class TPUTrainingArguments:
+    """Arguments for TPU training."""
+    output_dir: str = field(default="./output_tpu")
+
+    # Batch & accumulation
+    per_device_train_batch_size: int = field(default=1)
+    gradient_accumulation_steps: int = field(default=8)
+
+    # Learning rate
+    learning_rate: float = field(default=2e-5)
+    lr_scheduler_type: str = field(default="cosine")
+    warmup_ratio: float = field(default=0.1)
+    warmup_steps: int = field(default=100)
+
+    # Loss weights
+    ce_loss_weight: float = field(default=1.0)
+    diffusion_loss_weight: float = field(default=1.0)
+    ddpm_batch_mul: int = field(default=1)
+
+    # Gradient clipping
+    max_grad_norm: float = field(default=1.0)
+
+    # Training duration
+    max_steps: int = field(default=5000)
+    num_train_epochs: int = field(default=3)
+
+    # Logging & saving
+    logging_steps: int = field(default=10)
+    save_steps: int = field(default=500)
+    eval_steps: int = field(default=500)
+    save_total_limit: int = field(default=3)
+
+    # Gradient checkpointing
+    gradient_checkpointing: bool = field(default=True)
+
+    # EMA
+    ema_decay: float = field(default=0.999)
+
+    # Random seed
+    seed: int = field(default=42)
+
+    # Resume
+    resume_from_checkpoint: Optional[str] = field(default=None)
+
+
+# ============================================================================
+# SECTION 2: Helper Functions
+# ============================================================================
+
+def mask_for_ce(
+    labels: torch.Tensor,
+    attention_mask: torch.Tensor,
+    acoustic_input_mask: torch.Tensor,
+    pad_id: int = -100,
+) -> torch.Tensor:
+    """Build CE loss mask: only predict text tokens, not acoustic placeholders."""
+    shifted = labels[:, 1:].contiguous()
+    base_mask = (
+        attention_mask[:, 1:].contiguous().eq(1)
+        if (attention_mask is not None and attention_mask.numel() > 0)
+        else torch.ones_like(shifted, dtype=torch.bool)
+    )
+    label_is_acoustic = acoustic_input_mask[:, 1:].contiguous()
+    final_mask = base_mask & (~label_is_acoustic)
+    out = shifted.clone()
+    out[~final_mask] = pad_id
+    return out
+
+
+def _patch_acoustic_encode_for_legacy_indexing(model_obj, logger_):
+    """Patch acoustic tokenizer encode to return [[...]] for legacy indexing."""
+    try:
+        acoustic = getattr(getattr(model_obj, "model", model_obj), "acoustic_tokenizer", None)
+        if acoustic is None or not hasattr(acoustic, "encode"):
+            logger_.warning("No acoustic_tokenizer.encode() found to patch.")
+            return
+        base_encode = acoustic.encode
+
+        def encode_wrapped(*args, **kwargs):
+            out = base_encode(*args, **kwargs)
+            try:
+                _ = out[0][0]
+                return out
+            except Exception:
+                pass
+            if isinstance(out, dict):
+                for k in ("frames", "codes", "tokens", "latents", "hidden_states"):
+                    if k in out:
+                        return [[out[k]]]
+                if len(out) > 0:
+                    return [[next(iter(out.values()))]]
+            for attr in ("frames", "codes", "tokens", "latents", "hidden_states"):
+                if hasattr(out, attr):
+                    return [[getattr(out, attr)]]
+            try:
+                if isinstance(out, torch.Tensor):
+                    return [[out]]
+            except Exception:
+                pass
+            return [[out]]
+
+        acoustic.encode = encode_wrapped
+        logger_.info("Patched acoustic_tokenizer.encode() for legacy indexing.")
+    except Exception as e:
+        logger_.warning(f"Failed to patch acoustic_tokenizer.encode(): {e}")
+
+
+def _force_output_hidden_states(model):
+    """Monkey-patch the base model to always output hidden_states."""
+    original_forward = model.model.forward
+
+    @functools.wraps(original_forward)
+    def patched_forward(self, **kwargs):
+        kwargs["output_hidden_states"] = True
+        return original_forward(**kwargs)
+
+    model.model.forward = patched_forward.__get__(model.model, type(model.model))
+    logger.info("Patched VibeVoiceModel.forward to force output_hidden_states=True")
+
+
+def print_model_summary(model, logger_):
+    """Print a comprehensive summary of trainable vs frozen parameters."""
+    components = {
+        "LLM (language_model)": getattr(model.model, "language_model", None),
+        "LM Head": getattr(model, "lm_head", None),
+        "Diffusion Head (prediction_head)": getattr(model.model, "prediction_head", None),
+        "Surgery Module": getattr(model.model, "surgery_module", None),
+        "Acoustic Connector": getattr(model.model, "acoustic_connector", None),
+        "Semantic Connector": getattr(model.model, "semantic_connector", None),
+        "Acoustic Tokenizer": getattr(model.model, "acoustic_tokenizer", None),
+        "Semantic Tokenizer": getattr(model.model, "semantic_tokenizer", None),
+    }
+
+    total_all = 0
+    total_train = 0
+    logger_.info("=" * 70)
+    logger_.info("  MODEL PARAMETER SUMMARY")
+    logger_.info("=" * 70)
+
+    for name, mod in components.items():
+        if mod is None:
+            logger_.info(f"  {name:<40s} NOT FOUND")
+            continue
+        n_all = sum(p.numel() for p in mod.parameters())
+        n_train = sum(p.numel() for p in mod.parameters() if p.requires_grad)
+        pct = (100.0 * n_train / n_all) if n_all > 0 else 0.0
+        status = "TRAINABLE" if n_train > 0 else "FROZEN"
+        if n_train > 0 and n_train < n_all:
+            status = f"PARTIAL ({pct:.1f}%)"
+        logger_.info(f"  {name:<40s} {n_all:>14,}  total  |  {n_train:>14,}  train  |  {status}")
+        total_all += n_all
+        total_train += n_train
+
+    logger_.info("-" * 70)
+    logger_.info(f"  {'TOTAL':<40s} {total_all:>14,}  total  |  {total_train:>14,}  train")
+    logger_.info(f"  Trainable percentage: {100.0 * total_train / max(total_all, 1):.2f}%")
+    logger_.info("=" * 70)
+
+
+# ============================================================================
+# SECTION 3: LoRA Configuration
+# ============================================================================
+
+def build_lora_config(args: TPUModelArguments) -> LoraConfig:
+    """Build LoRA config for the LLM."""
+    target_modules = [s.strip() for s in args.lora_target_modules.split(",") if s.strip()]
+    return LoraConfig(
+        r=args.lora_r,
+        lora_alpha=args.lora_alpha,
+        lora_dropout=args.lora_dropout,
+        bias="none",
+        task_type=TaskType.CAUSAL_LM,
+        target_modules=target_modules,
+    )
+
+
+def build_head_lora_config(args: TPUModelArguments) -> LoraConfig:
+    """Build LoRA config for the Diffusion Head."""
+    target_modules = [
+        "noisy_images_proj", "cond_proj",
+        "gate_proj", "up_proj", "down_proj", "linear",
+    ]
+    return LoraConfig(
+        r=args.lora_r,
+        lora_alpha=args.lora_alpha,
+        lora_dropout=args.lora_dropout,
+        bias="none",
+        task_type=TaskType.FEATURE_EXTRACTION,
+        target_modules=target_modules,
+    )
+
+
+# ============================================================================
+# SECTION 4: Preprocessed Data Loading for TPU
+# ============================================================================
+
+class TPUPreprocessedDataset(torch.utils.data.Dataset):
+    """
+    Dataset that loads preprocessed .pt files from a directory.
+    
+    Each .pt file contains a list of batch dicts with tensors.
+    This class flattens all files into a single indexed dataset,
+    keeping tensors on CPU and letting the XLA data loader handle
+    device transfer.
+    """
+
+    def __init__(self, preprocessed_dir: str, logger_: logging.Logger):
+        super().__init__()
+        self.items: List[Dict[str, torch.Tensor]] = []
+
+        # Find all .pt files in the directory
+        pt_files = sorted([
+            os.path.join(preprocessed_dir, f)
+            for f in os.listdir(preprocessed_dir)
+            if f.endswith(".pt")
+        ])
+
+        if not pt_files:
+            raise FileNotFoundError(
+                f"No .pt files found in {preprocessed_dir}. "
+                "Please provide a directory with preprocessed .pt files."
+            )
+
+        logger_.info(f"Loading {len(pt_files)} preprocessed .pt files from {preprocessed_dir}")
+
+        for pt_file in pt_files:
+            try:
+                data = torch.load(pt_file, map_location="cpu")
+                if isinstance(data, list):
+                    # List of batch dicts
+                    for batch in data:
+                        if isinstance(batch, dict):
+                            self.items.append(batch)
+                    logger_.info(f"  Loaded {len(data)} batches from {os.path.basename(pt_file)}")
+                elif isinstance(data, dict):
+                    # Single batch dict
+                    self.items.append(data)
+                    logger_.info(f"  Loaded 1 batch from {os.path.basename(pt_file)}")
+                else:
+                    logger_.warning(f"  Skipping {os.path.basename(pt_file)}: unexpected format {type(data)}")
+            except Exception as e:
+                logger_.warning(f"  Failed to load {os.path.basename(pt_file)}: {e}")
+
+        if not self.items:
+            raise ValueError(
+                f"No valid batch data found in .pt files in {preprocessed_dir}"
+            )
+
+        logger_.info(f"Total preprocessed samples: {len(self.items)}")
+
+    def __len__(self) -> int:
+        return len(self.items)
+
+    def __getitem__(self, idx: int) -> Dict[str, torch.Tensor]:
+        item = self.items[idx]
+        result = {}
+        for k, v in item.items():
+            if isinstance(v, torch.Tensor):
+                result[k] = v.detach().clone()
+            elif v is None:
+                result[k] = None
+            else:
+                result[k] = v
+        return result
+
+
+class TPUBatchCollator:
+    """
+    Collator that concatenates pre-batched tensors along dim=0.
+    Used with preprocessed data where each item is already a batch.
+    """
+
+    def __call__(self, batch: List[Dict[str, Any]]) -> Dict[str, Any]:
+        if not batch:
+            return {}
+
+        result = {}
+        keys = batch[0].keys()
+
+        for key in keys:
+            tensors = []
+            for b in batch:
+                v = b.get(key)
+                if v is not None and isinstance(v, torch.Tensor):
+                    tensors.append(v)
+
+            if tensors:
+                # Check if we can concatenate (same ndim)
+                ndim = tensors[0].dim()
+                if all(t.dim() == ndim for t in tensors):
+                    result[key] = torch.cat(tensors, dim=0)
+                else:
+                    result[key] = tensors[0]
+            else:
+                # Use the first non-None value
+                for b in batch:
+                    v = b.get(key)
+                    if v is not None:
+                        result[key] = v
+                        break
+
+        return result
+
+
+# ============================================================================
+# SECTION 5: EMA (Exponential Moving Average)
+# ============================================================================
+
+class EMAModel:
+    """
+    EMA for the prediction head.
+    Maintains a shadow copy of parameters with exponential decay.
+    Compatible with TPU/XLA (uses CPU copies for shadow params).
+    """
+
+    def __init__(self, model: nn.Module, attr_path: str = "model.prediction_head", decay: float = 0.999):
+        self.attr_path = attr_path
+        self.decay = decay
+        self.shadow: Dict[str, torch.Tensor] = {}
+        self._orig: Optional[Dict[str, torch.Tensor]] = None
+
+    def _get_module(self, model: nn.Module) -> nn.Module:
+        mod = model
+        for name in self.attr_path.split('.'):
+            mod = getattr(mod, name)
+        return mod
+
+    def initialize(self, model: nn.Module):
+        """Initialize shadow parameters from model."""
+        head = self._get_module(model)
+        self.shadow = {
+            k: p.detach().cpu().float().clone()
+            for k, p in head.state_dict().items()
+        }
+        xm.master_print(f"EMA initialized with {len(self.shadow)} parameters")
+
+    def update(self, model: nn.Module):
+        """Update shadow parameters with current model parameters."""
+        if not self.shadow:
+            return
+        head = self._get_module(model)
+        with torch.no_grad():
+            for k, v in head.state_dict().items():
+                if k in self.shadow:
+                    # Move to CPU for shadow update
+                    v_cpu = v.detach().cpu().float()
+                    self.shadow[k].mul_(self.decay).add_(v_cpu, alpha=(1.0 - self.decay))
+
+    def apply_shadow(self, model: nn.Module) -> Dict[str, Any]:
+        """Swap in EMA parameters. Returns original state for restore."""
+        head = self._get_module(model)
+        self._orig = {k: v.clone() for k, v in head.state_dict().items()}
+        # Load shadow (CPU) to model device
+        device = next(head.parameters()).device
+        ema_state = {k: v.to(device) for k, v in self.shadow.items()}
+        head.load_state_dict(ema_state, strict=False)
+        return self._orig
+
+    def restore(self, model: nn.Module):
+        """Restore original parameters (swap back from EMA)."""
+        if self._orig is None:
+            return
+        head = self._get_module(model)
+        head.load_state_dict(self._orig, strict=False)
+        self._orig = None
+
+
+# ============================================================================
+# SECTION 6: Model Setup for TPU
+# ============================================================================
+
+def setup_model_for_tpu(
+    model_args: TPUModelArguments,
+    device: torch.device,
+) -> Tuple[VibeVoiceForConditionalGeneration, VibeVoiceProcessor]:
+    """
+    Load and configure VibeVoice model for TPU training.
+    
+    Returns:
+        (model, processor) tuple, both on the specified XLA device.
+    """
+    xm.master_print("=" * 70)
+    xm.master_print("  LOADING MODEL FOR TPU v5e-8 TRAINING")
+    xm.master_print("=" * 70)
+
+    # ── Load Processor ──
+    processor_path = model_args.processor_name_or_path or model_args.model_name_or_path
+    processor = VibeVoiceProcessor.from_pretrained(processor_path)
+
+    tok = processor.tokenizer
+    for required in ["speech_start_id", "speech_diffusion_id", "speech_end_id"]:
+        if not hasattr(tok, required) or getattr(tok, required) is None:
+            raise RuntimeError(f"Tokenizer missing required special id: {required}")
+
+    # ── Load Model ──
+    # Load in bf16 for TPU v5e compatibility
+    dtype = torch.bfloat16
+    xm.master_print(f"  Loading model in {dtype} precision...")
+
+    # Check if this is a surgery model (has Qwen3SurgeryModule)
+    try:
+        from vibevoice_surgery_colab import load_surgery_model
+        model = load_surgery_model(
+            model_args.model_name_or_path,
+            dtype=dtype,
+            device_map="cpu",
+        )
+        xm.master_print("  Loaded as surgery model")
+    except (ImportError, Exception):
+        model = VibeVoiceForConditionalGeneration.from_pretrained(
+            model_args.model_name_or_path,
+            torch_dtype=dtype,
+            device_map="cpu",
+        )
+        xm.master_print("  Loaded as standard VibeVoice model")
+
+    _patch_acoustic_encode_for_legacy_indexing(model, logger)
+    processor.semantic_tokenizer = getattr(model.model, "semantic_tokenizer", None)
+
+    # ── Verify Surgery Module ──
+    has_surgery = hasattr(model.model, "surgery_module")
+    if has_surgery:
+        sm = model.model.surgery_module
+        xm.master_print(f"  Surgery Module: {sm.extra_repr()}")
+    else:
+        xm.master_print("  No Surgery Module (standard model)")
+
+    # ── Force output_hidden_states ──
+    _force_output_hidden_states(model)
+
+    # ── Disable Cache ──
+    if hasattr(model.config, "use_cache"):
+        model.config.use_cache = False
+
+    # ── Tie LM Head ──
+    try:
+        emb = model.get_input_embeddings()
+        head = model.get_output_embeddings()
+        if hasattr(emb, "weight") and hasattr(head, "weight"):
+            if emb.weight.shape == head.weight.shape and emb.weight.data_ptr() != head.weight.data_ptr():
+                with torch.no_grad():
+                    head.weight = emb.weight
+                xm.master_print("  Force-tied LM head to embed_tokens")
+    except Exception as e:
+        logger.warning(f"Force-tie LM head failed: {e}")
+
+    # ======================================================================
+    # FREEZING STRATEGY
+    # ======================================================================
+    xm.master_print("\n  CONFIGURING LAYER FREEZING")
+
+    # Step 1: Freeze ALL
+    for _, p in model.named_parameters():
+        p.requires_grad = False
+
+    # Step 2: Tokenizers (always frozen)
+    if model_args.freeze_acoustic_tokenizer and hasattr(model.model, "acoustic_tokenizer"):
+        for p in model.model.acoustic_tokenizer.parameters():
+            p.requires_grad = False
+
+    if model_args.freeze_semantic_tokenizer and hasattr(model.model, "semantic_tokenizer"):
+        for p in model.model.semantic_tokenizer.parameters():
+            p.requires_grad = False
+
+    # Step 3: LoRA wrap LLM
+    tm_lower = [s.strip().lower() for s in model_args.lora_target_modules.split(",") if s.strip()]
+    skip_lm_lora = (len(tm_lower) == 0) or all(
+        t in ("none", "off", "disable", "disabled") for t in tm_lower
+    )
+
+    if not skip_lm_lora and not model_args.freeze_llm:
+        lora_cfg = build_lora_config(model_args)
+        model.model.language_model = get_peft_model(
+            model.model.language_model, lora_cfg
+        )
+        xm.master_print(f"  LLM wrapped with LoRA (r={model_args.lora_r}, alpha={model_args.lora_alpha})")
+    elif model_args.freeze_llm:
+        xm.master_print("  LLM: FROZEN (no LoRA)")
+    else:
+        xm.master_print("  LLM LoRA: SKIPPED (target_modules=none)")
+
+    # Step 4: Re-enable LoRA params
+    if not skip_lm_lora and not model_args.freeze_llm:
+        for n, p in model.model.language_model.named_parameters():
+            if "lora_A" in n or "lora_B" in n:
+                p.requires_grad = True
+
+    # Step 5: Diffusion Head
+    if model_args.train_diffusion_head:
+        for p in model.model.prediction_head.parameters():
+            p.requires_grad = True
+        xm.master_print("  Diffusion Head: FULL TRAIN")
+    elif model_args.lora_wrap_diffusion_head:
+        class _HeadShim(nn.Module):
+            def __init__(self, base):
+                super().__init__()
+                self.base = base
+
+            def forward(self, *args, **kwargs):
+                if len(args) >= 3:
+                    noisy_images, timesteps, condition = args[:3]
+                else:
+                    noisy_images = kwargs.get("noisy_images")
+                    timesteps = kwargs.get("timesteps")
+                    condition = kwargs.get("condition")
+                return self.base(noisy_images, timesteps, condition)
+
+        try:
+            shim = _HeadShim(model.model.prediction_head)
+            model.model.prediction_head = get_peft_model(shim, build_head_lora_config(model_args))
+            for n, p in model.model.prediction_head.named_parameters():
+                if "lora_A" in n or "lora_B" in n:
+                    p.requires_grad = True
+            xm.master_print("  Diffusion Head: LoRA WRAPPED")
+        except Exception as e:
+            logger.warning(f"Diffusion Head LoRA failed: {e}")
+    elif model_args.freeze_diffusion_head:
+        xm.master_print("  Diffusion Head: FROZEN")
+
+    # Step 6: Specific diffusion head layer freezing
+    if model_args.layers_to_freeze and hasattr(model.model, "prediction_head"):
+        head_params = list(model.model.prediction_head.named_parameters())
+        try:
+            indices = {int(x.strip()) for x in model_args.layers_to_freeze.split(",") if x.strip()}
+            for i, (name, param) in enumerate(head_params):
+                if i in indices:
+                    param.requires_grad = False
+                    xm.master_print(f"    Froze diffusion head param [{i}]: {name}")
+        except Exception as e:
+            logger.error(f"layers_to_freeze parse error: {e}")
+
+    # Step 7: Surgery Module
+    if hasattr(model.model, "surgery_module"):
+        if model_args.freeze_surgery_module:
+            for p in model.model.surgery_module.parameters():
+                p.requires_grad = False
+            xm.master_print("  Surgery Module: FROZEN")
+        else:
+            for p in model.model.surgery_module.parameters():
+                p.requires_grad = True
+            xm.master_print("  Surgery Module: TRAINABLE")
+
+    # Step 8: Connectors
+    if model_args.train_connectors:
+        if hasattr(model.model, "acoustic_connector"):
+            for p in model.model.acoustic_connector.parameters():
+                p.requires_grad = True
+        if hasattr(model.model, "semantic_connector"):
+            for p in model.model.semantic_connector.parameters():
+                p.requires_grad = True
+        xm.master_print("  Connectors: TRAINABLE")
+    elif model_args.freeze_connectors:
+        xm.master_print("  Connectors: FROZEN")
+
+    # Step 9: Freeze embedding + LM head
+    try:
+        emb = model.get_input_embeddings()
+        if hasattr(emb, "weight"):
+            emb.weight.requires_grad_(False)
+        head = model.get_output_embeddings()
+        if head is not None and hasattr(head, "weight"):
+            if model_args.freeze_lm_head:
+                head.weight.requires_grad_(False)
+                xm.master_print("  LM Head: FROZEN")
+    except Exception as e:
+        logger.warning(f"Embedding/head freeze failed: {e}")
+
+    # ── Print Summary ──
+    print_model_summary(model, logger)
+
+    # ── Move to TPU device ──
+    xm.master_print(f"\n  Moving model to XLA device: {device}")
+    model = model.to(device)
+    xm.master_print("  Model loaded on TPU successfully!")
+
+    return model, processor
+
+
+# ============================================================================
+# SECTION 7: Training Loop for TPU
+# ============================================================================
+
+class TPUScheduler:
+    """Learning rate scheduler compatible with TPU/XLA."""
+
+    def __init__(
+        self,
+        optimizer: torch.optim.Optimizer,
+        scheduler_type: str = "cosine",
+        num_warmup_steps: int = 100,
+        num_training_steps: int = 5000,
+        warmup_ratio: float = 0.1,
+    ):
+        self.optimizer = optimizer
+        self.scheduler_type = scheduler_type
+        self.num_warmup_steps = num_warmup_steps
+        self.num_training_steps = num_training_steps
+
+        if num_warmup_steps == 0 and warmup_ratio > 0:
+            self.num_warmup_steps = int(num_training_steps * warmup_ratio)
+
+        self.base_lrs = [group["lr"] for group in optimizer.param_groups]
+        self.current_step = 0
+
+    def get_lr_scale(self, step: int) -> float:
+        if step < self.num_warmup_steps:
+            return float(step) / float(max(1, self.num_warmup_steps))
+
+        if self.scheduler_type == "cosine":
+            progress = float(step - self.num_warmup_steps) / float(
+                max(1, self.num_training_steps - self.num_warmup_steps)
+            )
+            return max(0.0, 0.5 * (1.0 + math.cos(math.pi * progress)))
+        elif self.scheduler_type == "linear":
+            progress = float(step - self.num_warmup_steps) / float(
+                max(1, self.num_training_steps - self.num_warmup_steps)
+            )
+            return max(0.0, 1.0 - progress)
+        else:
+            return 1.0
+
+    def step(self):
+        self.current_step += 1
+        lr_scale = self.get_lr_scale(self.current_step)
+        for base_lr, group in zip(self.base_lrs, self.optimizer.param_groups):
+            group["lr"] = base_lr * lr_scale
+
+    def get_last_lr(self) -> float:
+        return self.optimizer.param_groups[0]["lr"]
+
+
+def compute_loss(
+    model: VibeVoiceForConditionalGeneration,
+    inputs: Dict[str, torch.Tensor],
+    ce_loss_weight: float = 1.0,
+    diffusion_loss_weight: float = 1.0,
+    ddpm_batch_mul: int = 1,
+) -> Tuple[torch.Tensor, Dict[str, float]]:
+    """
+    Compute the combined CE + Diffusion loss for VibeVoice.
+    
+    Returns:
+        (total_loss, metrics_dict)
+    """
+    labels = inputs.get("input_ids")
+    attention_mask = inputs.get("attention_mask")
+    acoustic_input_mask = inputs.get("acoustic_input_mask")
+
+    # Align semantic tensor dtype
+    sem = inputs.get("speech_semantic_tensors", None)
+    try:
+        target_dtype = next(model.model.semantic_connector.parameters()).dtype
+    except Exception:
+        target_dtype = model.get_input_embeddings().weight.dtype
+
+    if sem is None:
+        sm = inputs.get("speech_masks")
+        if sm is not None:
+            sem_dim = getattr(model.config, "semantic_vae_dim", 128)
+            inputs["speech_semantic_tensors"] = torch.zeros(
+                sm.size(0), sm.size(1), sem_dim,
+                dtype=target_dtype, device=sm.device,
+            )
+    elif isinstance(sem, torch.Tensor):
+        inputs["speech_semantic_tensors"] = sem.to(dtype=target_dtype)
+
+    # ── Forward ──
+    outputs = model(
+        input_ids=inputs.get("input_ids"),
+        attention_mask=attention_mask,
+        speech_tensors=inputs.get("speech_tensors"),
+        speech_masks=inputs.get("speech_masks"),
+        speech_semantic_tensors=inputs.get("speech_semantic_tensors"),
+        acoustic_input_mask=acoustic_input_mask,
+        acoustic_loss_mask=inputs.get("acoustic_loss_mask"),
+        speeches_loss_input=inputs.get("speeches_loss_input"),
+        ddpm_batch_mul=ddpm_batch_mul,
+        output_hidden_states=True,
+    )
+
+    # ── CE Loss ──
+    logits = outputs.logits
+    ce_labels = mask_for_ce(labels, attention_mask, acoustic_input_mask, pad_id=-100)
+    shift_logits = logits[:, :-1, :].contiguous()
+    loss_fct = nn.CrossEntropyLoss(ignore_index=-100)
+    ce_loss = loss_fct(shift_logits.view(-1, shift_logits.size(-1)), ce_labels.view(-1))
+
+    # ── Diffusion Loss ──
+    has_surgery = hasattr(model.model, "surgery_module")
+
+    if has_surgery and hasattr(outputs, "hidden_states") and outputs.hidden_states is not None:
+        diffusion_loss = _compute_surgery_diffusion_loss(
+            model, inputs, outputs, acoustic_input_mask, ddpm_batch_mul
+        )
+    else:
+        diffusion_loss = (
+            outputs.diffusion_loss
+            if outputs.diffusion_loss is not None
+            else torch.tensor(0.0, device=ce_loss.device, dtype=ce_loss.dtype)
+        )
+
+    # ── Combined Loss ──
+    total = ce_loss_weight * ce_loss + diffusion_loss_weight * diffusion_loss
+
+    metrics = {
+        "ce_loss": ce_loss.detach().item(),
+        "diffusion_loss": diffusion_loss.detach().item() if isinstance(diffusion_loss, torch.Tensor) else float(diffusion_loss),
+        "total_loss": total.detach().item(),
+    }
+
+    return total, metrics
+
+
+def _compute_surgery_diffusion_loss(
+    model: VibeVoiceForConditionalGeneration,
+    inputs: Dict[str, torch.Tensor],
+    outputs: Any,
+    acoustic_input_mask: torch.Tensor,
+    ddpm_batch_mul: int = 1,
+) -> torch.Tensor:
+    """Compute diffusion loss using Surgery Module to project hidden states."""
+    speech_tensors = inputs.get("speech_tensors")
+    speech_masks = inputs.get("speech_masks")
+    acoustic_loss_mask = inputs.get("acoustic_loss_mask")
+    speeches_loss_input = inputs.get("speeches_loss_input")
+
+    if speech_tensors is None or acoustic_loss_mask is None:
+        return sum(p.sum() for p in model.model.prediction_head.parameters()) * 0.0
+
+    if acoustic_loss_mask.sum().item() == 0:
+        return sum(p.sum() for p in model.model.prediction_head.parameters()) * 0.0
+
+    hidden_states = outputs.last_hidden_state
+
+    # Get ground truth acoustic features
+    x = model.get_input_embeddings()(inputs["input_ids"])
+    with torch.no_grad():
+        speech_all_features, _ = model.forward_speech_features(
+            speech_tensors=speech_tensors.type_as(x),
+            speech_masks=speech_masks,
+            return_unmask=True,
+        )
+    speech_features = speech_all_features[speeches_loss_input & speech_masks]
+
+    # Build condition from hidden states + Surgery Module
+    cond_mask = torch.zeros_like(acoustic_loss_mask, dtype=torch.bool)
+    cond_mask[:, :-1] = acoustic_loss_mask[:, 1:]
+    cond_mask[:, 0] = False
+    condition_features = hidden_states[cond_mask]
+
+    # Apply Surgery Module: 2560 → 3584
+    condition_features = model.model.surgery_module(condition_features)
+
+    speech_len, latent_size = speech_features.shape
+    noise = torch.randn(
+        (speech_len * ddpm_batch_mul, latent_size),
+        device=hidden_states.device,
+        dtype=hidden_states.dtype,
+    )
+    timesteps = torch.multinomial(
+        torch.ones(model.config.diffusion_head_config.ddpm_num_steps),
+        speech_len * ddpm_batch_mul,
+        replacement=True,
+    ).to(hidden_states.device)
+
+    speech_features_rep = speech_features.repeat_interleave(ddpm_batch_mul, dim=0)
+    condition_features_rep = condition_features.repeat_interleave(ddpm_batch_mul, dim=0)
+
+    noisy_speech = model.model.noise_scheduler.add_noise(speech_features_rep, noise, timesteps)
+    model_output = model.model.prediction_head(noisy_speech, timesteps.type_as(x), condition_features_rep)
+
+    prediction_type = model.config.diffusion_head_config.prediction_type
+    if prediction_type == "epsilon":
+        target = noise
+    elif prediction_type == "v_prediction":
+        target = model.model.noise_scheduler.get_velocity(speech_features_rep, noise, timesteps)
+    else:
+        raise NotImplementedError(f"Prediction type {prediction_type} not implemented")
+
+    loss = F.mse_loss(model_output.float(), target.float(), reduction="sum")
+    if latent_size > 0 and ddpm_batch_mul > 0:
+        loss = loss / latent_size / ddpm_batch_mul / max(speech_len, 1)
+    return loss
+
+
+# ============================================================================
+# SECTION 8: Checkpoint Save/Load
+# ============================================================================
+
+def save_checkpoint(
+    model: VibeVoiceForConditionalGeneration,
+    optimizer: torch.optim.Optimizer,
+    scheduler: TPUScheduler,
+    ema: EMAModel,
+    global_step: int,
+    output_dir: str,
+    save_total_limit: int = 3,
+):
+    """Save training checkpoint compatible with GPU inference."""
+    ckpt_dir = os.path.join(output_dir, f"checkpoint-{global_step}")
+    lora_out = os.path.join(ckpt_dir, "lora")
+    os.makedirs(lora_out, exist_ok=True)
+
+    xm.master_print(f"\n  Saving checkpoint at step {global_step} to {ckpt_dir}")
+
+    # Ensure we're saving the EMA version
+    ema.apply_shadow(model)
+
+    # ── LLM LoRA adapters ──
+    lm = getattr(model.model, "language_model", None)
+    if hasattr(lm, "save_pretrained"):
+        lm.save_pretrained(lora_out)
+
+    # ── Diffusion Head ──
+    ph = getattr(model.model, "prediction_head", None)
+    if ph is not None and hasattr(ph, "state_dict"):
+        sd = ph.state_dict()
+        # Save to CPU for cross-device compatibility
+        sd_cpu = {k: v.cpu() for k, v in sd.items()}
+        torch.save(sd_cpu, os.path.join(lora_out, "diffusion_head_full.bin"))
+
+        if hasattr(ph, "save_pretrained"):
+            ph_dir = os.path.join(lora_out, "diffusion_head")
+            os.makedirs(ph_dir, exist_ok=True)
+            ph.save_pretrained(ph_dir)
+            torch.save(sd_cpu, os.path.join(ph_dir, "diffusion_head_full.bin"))
+
+    # ── Connectors ──
+    for conn_name in ["acoustic_connector", "semantic_connector"]:
+        conn = getattr(model.model, conn_name, None)
+        if conn is not None:
+            conn_dir = os.path.join(lora_out, conn_name)
+            os.makedirs(conn_dir, exist_ok=True)
+            sd = {k: v.cpu() for k, v in conn.state_dict().items()}
+            torch.save(sd, os.path.join(conn_dir, "pytorch_model.bin"))
+
+    # ── Surgery Module ──
+    sm = getattr(model.model, "surgery_module", None)
+    if sm is not None:
+        sm_dir = os.path.join(lora_out, "surgery_module")
+        os.makedirs(sm_dir, exist_ok=True)
+        sd = {k: v.cpu() for k, v in sm.state_dict().items()}
+        torch.save(sd, os.path.join(sm_dir, "pytorch_model.bin"))
+
+    # ── Training state ──
+    training_state = {
+        "global_step": global_step,
+        "optimizer_state": {
+            "param_groups": optimizer.param_groups,
+        },
+        "scheduler_step": scheduler.current_step,
+        "ema_decay": ema.decay,
+    }
+    # Move optimizer states to CPU for saving
+    optimizer_state_dict = {}
+    for k, v in optimizer.state_dict().items():
+        if isinstance(v, dict):
+            cpu_v = {}
+            for kk, vv in v.items():
+                if isinstance(vv, torch.Tensor):
+                    cpu_v[kk] = vv.cpu()
+                else:
+                    cpu_v[kk] = vv
+            optimizer_state_dict[k] = cpu_v
+        elif isinstance(v, torch.Tensor):
+            optimizer_state_dict[k] = v.cpu()
+        else:
+            optimizer_state_dict[k] = v
+    training_state["optimizer_state_dict"] = optimizer_state_dict
+
+    torch.save(training_state, os.path.join(ckpt_dir, "training_state.pt"))
+
+    # Restore original parameters
+    ema.restore(model)
+
+    xm.master_print(f"  Checkpoint saved: {ckpt_dir}")
+
+    # ── Cleanup old checkpoints ──
+    _cleanup_old_checkpoints(output_dir, save_total_limit, global_step)
+
+
+def _cleanup_old_checkpoints(output_dir: str, save_total_limit: int, current_step: int):
+    """Remove old checkpoints keeping only the most recent ones."""
+    if save_total_limit <= 0:
+        return
+
+    checkpoint_dirs = []
+    for d in os.listdir(output_dir):
+        if d.startswith("checkpoint-"):
+            try:
+                step = int(d.split("-")[1])
+                checkpoint_dirs.append((step, os.path.join(output_dir, d)))
+            except (ValueError, IndexError):
+                pass
+
+    checkpoint_dirs.sort(key=lambda x: x[0])
+
+    while len(checkpoint_dirs) > save_total_limit:
+        step, path = checkpoint_dirs.pop(0)
+        if step != current_step:
+            import shutil
+            shutil.rmtree(path, ignore_errors=True)
+            xm.master_print(f"  Removed old checkpoint: {path}")
+
+
+def load_checkpoint(
+    checkpoint_path: str,
+    model: VibeVoiceForConditionalGeneration,
+    optimizer: torch.optim.Optimizer,
+    scheduler: TPUScheduler,
+) -> int:
+    """Load training checkpoint and return the global step."""
+    xm.master_print(f"\n  Resuming from checkpoint: {checkpoint_path}")
+
+    lora_dir = os.path.join(checkpoint_path, "lora")
+    if not os.path.exists(lora_dir):
+        xm.master_print(f"  No 'lora' directory found in {checkpoint_path}")
+        return 0
+
+    # ── Load LLM LoRA ──
+    lm = getattr(model.model, "language_model", None)
+    if hasattr(lm, "save_pretrained"):
+        try:
+            from peft import load_peft_weights, set_peft_model_state_dict
+            adapters_weights = load_peft_weights(lora_dir)
+            set_peft_model_state_dict(model.model.language_model, adapters_weights)
+            xm.master_print("  Loaded LLM LoRA weights")
+        except Exception as e:
+            logger.warning(f"Could not load LLM LoRA: {e}")
+
+    # ── Load Diffusion Head ──
+    ph_path = os.path.join(lora_dir, "diffusion_head_full.bin")
+    if os.path.exists(ph_path) and hasattr(model.model, "prediction_head"):
+        try:
+            model.model.prediction_head.load_state_dict(
+                torch.load(ph_path, map_location="cpu"), strict=False
+            )
+            xm.master_print("  Loaded Diffusion Head weights")
+        except Exception as e:
+            logger.warning(f"Failed to load Diffusion Head: {e}")
+
+    # ── Load Connectors ──
+    for conn_name in ["acoustic_connector", "semantic_connector"]:
+        conn_path = os.path.join(lora_dir, conn_name, "pytorch_model.bin")
+        conn = getattr(model.model, conn_name, None)
+        if os.path.exists(conn_path) and conn is not None:
+            try:
+                conn.load_state_dict(torch.load(conn_path, map_location="cpu"))
+                xm.master_print(f"  Loaded {conn_name}")
+            except Exception as e:
+                logger.warning(f"Failed to load {conn_name}: {e}")
+
+    # ── Load Surgery Module ──
+    sm_path = os.path.join(lora_dir, "surgery_module", "pytorch_model.bin")
+    sm = getattr(model.model, "surgery_module", None)
+    if os.path.exists(sm_path) and sm is not None:
+        try:
+            sm.load_state_dict(torch.load(sm_path, map_location="cpu"))
+            xm.master_print("  Loaded Surgery Module weights")
+        except Exception as e:
+            logger.warning(f"Failed to load Surgery Module: {e}")
+
+    # ── Load Training State ──
+    state_path = os.path.join(checkpoint_path, "training_state.pt")
+    global_step = 0
+    if os.path.exists(state_path):
+        try:
+            training_state = torch.load(state_path, map_location="cpu")
+            global_step = training_state.get("global_step", 0)
+            scheduler.current_step = training_state.get("scheduler_step", 0)
+            xm.master_print(f"  Resumed at global_step={global_step}")
+        except Exception as e:
+            logger.warning(f"Failed to load training state: {e}")
+
+    return global_step
+
+
+# ============================================================================
+# SECTION 9: Main Training Function (per-TPU process)
+# ============================================================================
+
+def train_fn(rank: int, model_args: TPUModelArguments, data_args: TPUDataArguments,
+             training_args: TPUTrainingArguments):
+    """
+    Main training function executed on each TPU chip.
+    
+    Args:
+        rank: TPU chip index (0-7)
+        model_args: Model configuration
+        data_args: Data configuration
+        training_args: Training configuration
+    """
+    # ── Setup ──
+    device = xm.xla_device()
+    xm.master_print(f"\n{'='*70}")
+    xm.master_print(f"  TPU v5e-8 Fine-Tuning | Process {rank} | Device: {device}")
+    xm.master_print(f"{'='*70}")
+
+    set_seed(training_args.seed + rank)
+
+    # ── Load Model ──
+    model, processor = setup_model_for_tpu(model_args, device)
+
+    # ── Load Preprocessed Data ──
+    xm.master_print(f"\n  Loading preprocessed data from {data_args.preprocessed_dir}")
+    full_dataset = TPUPreprocessedDataset(data_args.preprocessed_dir, logger)
+
+    # ── Train/Eval Split ──
+    eval_dataset = None
+    if data_args.eval_split_size > 0 and len(full_dataset) > 1:
+        num_eval = max(1, int(len(full_dataset) * data_args.eval_split_size))
+        num_train = len(full_dataset) - num_eval
+        indices = list(range(len(full_dataset)))
+        random.Random(training_args.seed).shuffle(indices)
+
+        train_dataset = torch.utils.data.Subset(full_dataset, indices[:num_train])
+        eval_dataset = torch.utils.data.Subset(full_dataset, indices[num_train:])
+        xm.master_print(f"  Train samples: {len(train_dataset)}, Eval samples: {len(eval_dataset)}")
+    else:
+        train_dataset = full_dataset
+        xm.master_print(f"  Train samples: {len(train_dataset)}")
+
+    # ── Data Loaders ──
+    train_sampler = torch.utils.data.distributed.DistributedSampler(
+        train_dataset,
+        num_replicas=xm.xrt_world_size(),
+        rank=xm.get_ordinal(),
+        shuffle=True,
+        seed=training_args.seed,
+    )
+
+    train_loader = torch.utils.data.DataLoader(
+        train_dataset,
+        batch_size=training_args.per_device_train_batch_size,
+        sampler=train_sampler,
+        collate_fn=TPUBatchCollator(),
+        num_workers=0,  # Use 0 for TPU (data on CPU, transferred via XLA)
+        pin_memory=False,
+        drop_last=True,
+    )
+
+    # Wrap with MpDeviceLoader for TPU
+    train_device_loader = pl.MpDeviceLoader(train_loader, device)
+
+    eval_device_loader = None
+    if eval_dataset is not None:
+        eval_sampler = torch.utils.data.distributed.DistributedSampler(
+            eval_dataset,
+            num_replicas=xm.xrt_world_size(),
+            rank=xm.get_ordinal(),
+            shuffle=False,
+        )
+        eval_loader = torch.utils.data.DataLoader(
+            eval_dataset,
+            batch_size=training_args.per_device_train_batch_size,
+            sampler=eval_sampler,
+            collate_fn=TPUBatchCollator(),
+            num_workers=0,
+            pin_memory=False,
+            drop_last=False,
+        )
+        eval_device_loader = pl.MpDeviceLoader(eval_loader, device)
+
+    # ── Optimizer ──
+    trainable_params = [p for p in model.parameters() if p.requires_grad]
+    xm.master_print(f"\n  Trainable parameters: {sum(p.numel() for p in trainable_params):,}")
+
+    optimizer = torch.optim.AdamW(
+        trainable_params,
+        lr=training_args.learning_rate,
+        betas=(0.9, 0.999),
+        eps=1e-8,
+        weight_decay=0.01,
+    )
+
+    # ── Scheduler ──
+    scheduler = TPUScheduler(
+        optimizer,
+        scheduler_type=training_args.lr_scheduler_type,
+        num_warmup_steps=training_args.warmup_steps,
+        num_training_steps=training_args.max_steps,
+        warmup_ratio=training_args.warmup_ratio,
+    )
+
+    # ── EMA ──
+    ema = EMAModel(
+        model,
+        attr_path="model.prediction_head",
+        decay=training_args.ema_decay,
+    )
+    ema.initialize(model)
+
+    # ── Gradient Checkpointing ──
+    if training_args.gradient_checkpointing:
+        try:
+            model.gradient_checkpointing_enable()
+            xm.master_print("  Gradient checkpointing enabled")
+        except Exception as e:
+            logger.warning(f"Failed to enable gradient checkpointing: {e}")
+
+    # ── Resume from Checkpoint ──
+    global_step = 0
+    if training_args.resume_from_checkpoint and os.path.exists(training_args.resume_from_checkpoint):
+        global_step = load_checkpoint(
+            training_args.resume_from_checkpoint, model, optimizer, scheduler
+        )
+        # Move model back to device after loading CPU weights
+        model = model.to(device)
+
+    # ── Training Loop ──
+    xm.master_print(f"\n{'='*70}")
+    xm.master_print(f"  STARTING TRAINING")
+    xm.master_print(f"  Max steps: {training_args.max_steps}")
+    xm.master_print(f"  Gradient accumulation: {training_args.gradient_accumulation_steps}")
+    xm.master_print(f"  Effective batch size: {training_args.per_device_train_batch_size} × {xm.xrt_world_size()} × {training_args.gradient_accumulation_steps}")
+    xm.master_print(f"{'='*70}\n")
+
+    model.train()
+    optimizer.zero_grad()
+
+    accum_steps = training_args.gradient_accumulation_steps
+    log_steps = training_args.logging_steps
+    save_steps = training_args.save_steps
+    eval_steps = training_args.eval_steps
+
+    running_metrics: Dict[str, float] = {}
+    step_loss = 0.0
+    step_count = 0
+    start_time = time.time()
+    epoch = 0
+
+    while global_step < training_args.max_steps:
+        epoch += 1
+        train_sampler.set_epoch(epoch)
+        xm.master_print(f"\n  === Epoch {epoch} ===")
+
+        for batch_idx, batch in enumerate(train_device_loader):
+            if global_step >= training_args.max_steps:
+                break
+
+            # ── Forward + Backward ──
+            with autocast(device=device, dtype=torch.bfloat16):
+                loss, metrics = compute_loss(
+                    model, batch,
+                    ce_loss_weight=training_args.ce_loss_weight,
+                    diffusion_loss_weight=training_args.diffusion_loss_weight,
+                    ddpm_batch_mul=training_args.ddpm_batch_mul,
+                )
+                loss = loss / accum_steps
+
+            loss.backward()
+
+            # Accumulate metrics
+            for k, v in metrics.items():
+                running_metrics[k] = running_metrics.get(k, 0.0) + v
+            step_loss += loss.item()
+            step_count += 1
+
+            # ── Gradient Accumulation Sync ──
+            if (batch_idx + 1) % accum_steps == 0:
+                # Gradient clipping
+                if training_args.max_grad_norm > 0:
+                    torch.nn.utils.clip_grad_norm_(
+                        trainable_params, training_args.max_grad_norm
+                    )
+
+                # Optimizer step (XLA synchronized)
+                xm.optimizer_step(optimizer)
+                optimizer.zero_grad()
+
+                # Scheduler step
+                scheduler.step()
+
+                # EMA update
+                ema.update(model)
+
+                global_step += 1
+
+                # ── Logging ──
+                if global_step % log_steps == 0:
+                    elapsed = time.time() - start_time
+                    avg_loss = step_loss / max(step_count, 1)
+                    lr = scheduler.get_last_lr()
+
+                    avg_metrics = {
+                        k: v / max(step_count, 1) for k, v in running_metrics.items()
+                    }
+
+                    xm.master_print(
+                        f"  Step {global_step}/{training_args.max_steps} | "
+                        f"Loss: {avg_loss:.4f} | "
+                        f"CE: {avg_metrics.get('ce_loss', 0):.4f} | "
+                        f"Diff: {avg_metrics.get('diffusion_loss', 0):.4f} | "
+                        f"LR: {lr:.2e} | "
+                        f"Time: {elapsed:.1f}s"
+                    )
+
+                    running_metrics = {}
+                    step_loss = 0.0
+                    step_count = 0
+                    start_time = time.time()
+
+                # ── Evaluation ──
+                if eval_device_loader is not None and global_step % eval_steps == 0:
+                    eval_loss = _evaluate(model, eval_device_loader, training_args, device)
+                    xm.master_print(f"  [EVAL] Step {global_step} | Loss: {eval_loss:.4f}")
+
+                # ── Save Checkpoint ──
+                if global_step % save_steps == 0:
+                    xm.rendezvous("save_checkpoint")
+                    save_checkpoint(
+                        model, optimizer, scheduler, ema,
+                        global_step, training_args.output_dir,
+                        training_args.save_total_limit,
+                    )
+
+            # Mark step for XLA compilation
+            xm.mark_step()
+
+    # ── Final Save ──
+    xm.rendezvous("final_save")
+    save_checkpoint(
+        model, optimizer, scheduler, ema,
+        global_step, training_args.output_dir,
+        training_args.save_total_limit,
+    )
+
+    # Also save final model in a clean format
+    _save_final_model(model, ema, training_args.output_dir)
+
+    xm.master_print(f"\n{'='*70}")
+    xm.master_print(f"  TRAINING COMPLETE!")
+    xm.master_print(f"  Total steps: {global_step}")
+    xm.master_print(f"  Model saved to: {training_args.output_dir}")
+    xm.master_print(f"{'='*70}")
+
+
+def _evaluate(
+    model: VibeVoiceForConditionalGeneration,
+    eval_loader: pl.MpDeviceLoader,
+    training_args: TPUTrainingArguments,
+    device: torch.device,
+) -> float:
+    """Run evaluation and return average loss."""
+    model.eval()
+    total_loss = 0.0
+    num_batches = 0
+
+    with torch.no_grad():
+        for batch in eval_loader:
+            with autocast(device=device, dtype=torch.bfloat16):
+                loss, _ = compute_loss(
+                    model, batch,
+                    ce_loss_weight=training_args.ce_loss_weight,
+                    diffusion_loss_weight=training_args.diffusion_loss_weight,
+                    ddpm_batch_mul=training_args.ddpm_batch_mul,
+                )
+            total_loss += loss.item()
+            num_batches += 1
+            xm.mark_step()
+
+            if num_batches >= 50:  # Limit eval batches
+                break
+
+    model.train()
+    avg_loss = total_loss / max(num_batches, 1)
+
+    # All-reduce eval loss across TPU chips
+    loss_tensor = torch.tensor([avg_loss], device=device)
+    xm.all_reduce("sum", [loss_tensor])
+    avg_loss = loss_tensor.item() / xm.xrt_world_size()
+
+    return avg_loss
+
+
+def _save_final_model(
+    model: VibeVoiceForConditionalGeneration,
+    ema: EMAModel,
+    output_dir: str,
+):
+    """Save the final trained model in a clean format."""
+    final_dir = os.path.join(output_dir, "final_model")
+    lora_out = os.path.join(final_dir, "lora")
+    os.makedirs(lora_out, exist_ok=True)
+
+    xm.master_print(f"\n  Saving final model to {final_dir}")
+
+    # Apply EMA for final save
+    ema.apply_shadow(model)
+
+    # Save all components
+    lm = getattr(model.model, "language_model", None)
+    if hasattr(lm, "save_pretrained"):
+        lm.save_pretrained(lora_out)
+
+    ph = getattr(model.model, "prediction_head", None)
+    if ph is not None and hasattr(ph, "state_dict"):
+        sd = {k: v.cpu() for k, v in ph.state_dict().items()}
+        torch.save(sd, os.path.join(lora_out, "diffusion_head_full.bin"))
+
+    for conn_name in ["acoustic_connector", "semantic_connector"]:
+        conn = getattr(model.model, conn_name, None)
+        if conn is not None:
+            conn_dir = os.path.join(lora_out, conn_name)
+            os.makedirs(conn_dir, exist_ok=True)
+            sd = {k: v.cpu() for k, v in conn.state_dict().items()}
+            torch.save(sd, os.path.join(conn_dir, "pytorch_model.bin"))
+
+    sm = getattr(model.model, "surgery_module", None)
+    if sm is not None:
+        sm_dir = os.path.join(lora_out, "surgery_module")
+        os.makedirs(sm_dir, exist_ok=True)
+        sd = {k: v.cpu() for k, v in sm.state_dict().items()}
+        torch.save(sd, os.path.join(sm_dir, "pytorch_model.bin"))
+
+    ema.restore(model)
+    xm.master_print(f"  Final model saved to {final_dir}")
+
+
+# ============================================================================
+# SECTION 10: Entry Point
+# ============================================================================
+
+def main():
+    """Parse arguments and launch TPU training."""
+    import argparse
+
+    parser = argparse.ArgumentParser(
+        description="VibeVoice Fine-Tuning on TPU v5e-8",
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+    )
+
+    # Model arguments
+    parser.add_argument("--model_name_or_path", type=str, required=True,
+                        help="Path to VibeVoice/surgery model directory")
+    parser.add_argument("--processor_name_or_path", type=str, default=None,
+                        help="Path to processor directory")
+
+    # Freezing
+    parser.add_argument("--freeze_llm", action="store_true", default=False)
+    parser.add_argument("--no_freeze_llm", dest="freeze_llm", action="store_false")
+    parser.add_argument("--freeze_diffusion_head", action="store_true", default=True)
+    parser.add_argument("--no_freeze_diffusion_head", dest="freeze_diffusion_head", action="store_false")
+    parser.add_argument("--freeze_surgery_module", action="store_true", default=False)
+    parser.add_argument("--freeze_connectors", action="store_true", default=False)
+    parser.add_argument("--train_diffusion_head", action="store_true", default=False)
+    parser.add_argument("--train_connectors", action="store_true", default=True)
+    parser.add_argument("--train_surgery_module", action="store_true", default=True)
+    parser.add_argument("--lora_wrap_diffusion_head", action="store_true", default=False)
+
+    # LoRA
+    parser.add_argument("--lora_r", type=int, default=8)
+    parser.add_argument("--lora_alpha", type=int, default=32)
+    parser.add_argument("--lora_dropout", type=float, default=0.05)
+    parser.add_argument("--lora_target_modules", type=str,
+                        default="q_proj,k_proj,v_proj,o_proj,gate_proj,up_proj,down_proj")
+    parser.add_argument("--layers_to_freeze", type=str, default=None)
+
+    # Data
+    parser.add_argument("--preprocessed_dir", type=str, required=True,
+                        help="Directory containing preprocessed .pt files")
+    parser.add_argument("--eval_split_size", type=float, default=0.05)
+
+    # Training
+    parser.add_argument("--output_dir", type=str, default="./output_tpu")
+    parser.add_argument("--max_steps", type=int, default=5000)
+    parser.add_argument("--num_train_epochs", type=int, default=3)
+    parser.add_argument("--learning_rate", type=float, default=2e-5)
+    parser.add_argument("--lr_scheduler_type", type=str, default="cosine")
+    parser.add_argument("--warmup_steps", type=int, default=100)
+    parser.add_argument("--warmup_ratio", type=float, default=0.1)
+    parser.add_argument("--per_device_train_batch_size", type=int, default=1)
+    parser.add_argument("--gradient_accumulation_steps", type=int, default=8)
+    parser.add_argument("--max_grad_norm", type=float, default=1.0)
+    parser.add_argument("--gradient_checkpointing", action="store_true", default=True)
+    parser.add_argument("--no_gradient_checkpointing", dest="gradient_checkpointing", action="store_false")
+
+    # Loss weights
+    parser.add_argument("--ce_loss_weight", type=float, default=1.0)
+    parser.add_argument("--diffusion_loss_weight", type=float, default=1.0)
+    parser.add_argument("--ddpm_batch_mul", type=int, default=1)
+
+    # Logging & saving
+    parser.add_argument("--logging_steps", type=int, default=10)
+    parser.add_argument("--save_steps", type=int, default=500)
+    parser.add_argument("--eval_steps", type=int, default=500)
+    parser.add_argument("--save_total_limit", type=int, default=3)
+
+    # EMA
+    parser.add_argument("--ema_decay", type=float, default=0.999)
+
+    # Resume
+    parser.add_argument("--resume_from_checkpoint", type=str, default=None)
+
+    # Seed
+    parser.add_argument("--seed", type=int, default=42)
+
+    args = parser.parse_args()
+
+    # Build argument dataclasses
+    model_args = TPUModelArguments(
+        model_name_or_path=args.model_name_or_path,
+        processor_name_or_path=args.processor_name_or_path,
+        freeze_llm=args.freeze_llm,
+        freeze_diffusion_head=args.freeze_diffusion_head,
+        freeze_surgery_module=args.freeze_surgery_module,
+        freeze_connectors=args.freeze_connectors,
+        freeze_acoustic_tokenizer=True,
+        freeze_semantic_tokenizer=True,
+        freeze_lm_head=True,
+        lora_r=args.lora_r,
+        lora_alpha=args.lora_alpha,
+        lora_dropout=args.lora_dropout,
+        lora_target_modules=args.lora_target_modules,
+        lora_wrap_diffusion_head=args.lora_wrap_diffusion_head,
+        train_diffusion_head=args.train_diffusion_head,
+        train_connectors=args.train_connectors,
+        train_surgery_module=args.train_surgery_module,
+        layers_to_freeze=args.layers_to_freeze,
+    )
+
+    data_args = TPUDataArguments(
+        preprocessed_dir=args.preprocessed_dir,
+        eval_split_size=args.eval_split_size,
+        seed=args.seed,
+    )
+
+    training_args = TPUTrainingArguments(
+        output_dir=args.output_dir,
+        per_device_train_batch_size=args.per_device_train_batch_size,
+        gradient_accumulation_steps=args.gradient_accumulation_steps,
+        learning_rate=args.learning_rate,
+        lr_scheduler_type=args.lr_scheduler_type,
+        warmup_ratio=args.warmup_ratio,
+        warmup_steps=args.warmup_steps,
+        ce_loss_weight=args.ce_loss_weight,
+        diffusion_loss_weight=args.diffusion_loss_weight,
+        ddpm_batch_mul=args.ddpm_batch_mul,
+        max_grad_norm=args.max_grad_norm,
+        max_steps=args.max_steps,
+        num_train_epochs=args.num_train_epochs,
+        logging_steps=args.logging_steps,
+        save_steps=args.save_steps,
+        eval_steps=args.eval_steps,
+        save_total_limit=args.save_total_limit,
+        gradient_checkpointing=args.gradient_checkpointing,
+        ema_decay=args.ema_decay,
+        seed=args.seed,
+        resume_from_checkpoint=args.resume_from_checkpoint,
+    )
+
+    # ── Print Configuration ──
+    xm.master_print(f"\n{'='*70}")
+    xm.master_print(f"  VibeVoice TPU v5e-8 Fine-Tuning Configuration")
+    xm.master_print(f"{'='*70}")
+    xm.master_print(f"  Model:           {model_args.model_name_or_path}")
+    xm.master_print(f"  Data:            {data_args.preprocessed_dir}")
+    xm.master_print(f"  Output:          {training_args.output_dir}")
+    xm.master_print(f"  Precision:       bfloat16 (TPU native)")
+    xm.master_print(f"  Max steps:       {training_args.max_steps}")
+    xm.master_print(f"  Batch size:      {training_args.per_device_train_batch_size}")
+    xm.master_print(f"  Grad accum:      {training_args.gradient_accumulation_steps}")
+    xm.master_print(f"  LR:              {training_args.learning_rate}")
+    xm.master_print(f"  LoRA r:          {model_args.lora_r}")
+    xm.master_print(f"  Grad checkpoint: {training_args.gradient_checkpointing}")
+    xm.master_print(f"  Surgery module:  {'TRAINABLE' if model_args.train_surgery_module else 'FROZEN'}")
+    xm.master_print(f"  Connectors:      {'TRAINABLE' if model_args.train_connectors else 'FROZEN'}")
+    xm.master_print(f"{'='*70}\n")
+
+    # ── Create output directory ──
+    os.makedirs(training_args.output_dir, exist_ok=True)
+
+    # ── Launch training ──
+    # Use xmp.spawn for multi-process TPU training
+    xmp.spawn(
+        train_fn,
+        args=(model_args, data_args, training_args),
+        nprocs=TPU_CONFIG["num_chips"],
+        start_method="fork",
+    )
+
+
+if __name__ == "__main__":
+    main()

VibeVoice-tpu/src/finetune_vibevoice_tpu_colab.ipynb

@@ -0,0 +1,1172 @@
+{
+    "nbformat": 4,
+    "nbformat_minor": 0,
+    "metadata": {
+        "colab": {
+            "provenance": [],
+            "gpuType": "TPU"
+        },
+        "kernelspec": {
+            "name": "python3",
+            "display_name": "Python 3"
+        },
+        "language_info": {
+            "name": "python"
+        },
+        "accelerator": "TPU"
+    },
+    "cells": [
+        {
+            "cell_type": "markdown",
+            "metadata": {},
+            "source": [
+                "# 🎙️ VibeVoice Fine-Tuning on TPU (Google Colab)\n",
+                "\n",
+                "## Overview\n",
+                "\n",
+                "This notebook fine-tunes the **VibeVoice surgery model** (Qwen3-4B backbone + Surgery Module) on **Google Colab TPU** using PyTorch/XLA.\n",
+                "\n",
+                "### Key Differences from GPU Training\n",
+                "| Aspect | GPU (T4) | TPU |\n",
+                "|--------|----------|-----|\n",
+                "| Framework | PyTorch + CUDA | PyTorch/XLA |\n",
+                "| Precision | fp16 | bfloat16 (native) |\n",
+                "| Training Loop | HF Trainer | Custom XLA loop |\n",
+                "| Data Loading | DataLoader | MpDeviceLoader |\n",
+                "| 8 Cores | N/A | 8 TPU cores (data parallel) |\n",
+                "| Memory | 15 GB (T4) | 8 GB HBM per core × 8 = 64 GB total |\n",
+                "\n",
+                "### Model Architecture After Surgery\n",
+                "| Component | Dimensions | Notes |\n",
+                "|-----------|-----------|-------|\n",
+                "| Qwen3-4B LLM | 2560-dim, 36 layers | Language model backbone |\n",
+                "| Surgery Module | 2560 → 3584 | Bridging module for diffusion head |\n",
+                "| Diffusion Head | 3584-dim | DDPM-based speech generation |\n",
+                "| Acoustic Connector | 64 → 2560 | Acoustic latent → LLM space |\n",
+                "| Semantic Connector | 128 → 2560 | Semantic latent → LLM space |\n",
+                "\n",
+                "### Data Format\n",
+                "This notebook expects **preprocessed `.pt` files** in a directory.\n",
+                "Each `.pt` file contains a list of batch dicts with tensors:\n",
+                "- `input_ids`, `attention_mask`, `speech_tensors`, `speech_masks`\n",
+                "- `speech_semantic_tensors`, `acoustic_input_mask`, `acoustic_loss_mask`, `speeches_loss_input`\n",
+                "\n",
+                "---"
+            ]
+        },
+        {
+            "cell_type": "markdown",
+            "metadata": {},
+            "source": [
+                "## Cell 1: 🔧 Environment Setup & Dependencies"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "metadata": {},
+            "source": [
+                "#@title 1.1 — Install PyTorch/XLA and Dependencies { display-mode: \"form\" }\n",
+                "import subprocess, sys, os\n",
+                "\n",
+                "def install(package):\n",
+                "    subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", \"-q\", package])\n",
+                "\n",
+                "# Install PyTorch/XLA (CRITICAL for TPU support)\n",
+                "# Match version to your Colab TPU runtime\n",
+                "!pip install torch~=2.5.0\n",
+                "!pip install torch_xla[tpu]~=2.5.0 -f https://storage.googleapis.com/libtpu-releases/index.html\n",
+                "\n",
+                "# Core ML stack\n",
+                "install(\"transformers>=4.45.0\")\n",
+                "install(\"peft>=0.7.0\")\n",
+                "install(\"datasets>=2.19.0\")\n",
+                "install(\"safetensors>=0.4.0\")\n",
+                "\n",
+                "# Audio processing (optional — only needed for raw audio)\n",
+                "# install(\"librosa>=0.10.0\")\n",
+                "# install(\"soundfile>=0.12.0\")\n",
+                "\n",
+                "# Utilities\n",
+                "install(\"sentencepiece\")\n",
+                "install(\"protobuf\")\n",
+                "install(\"tqdm\")\n",
+                "install(\"numpy\")\n",
+                "\n",
+                "print(\"✅ All dependencies installed successfully!\")"
+            ],
+            "execution_count": null,
+            "outputs": []
+        },
+        {
+            "cell_type": "code",
+            "metadata": {},
+            "source": [
+                "#@title 1.2 — Verify TPU Setup { display-mode: \"form\" }\n",
+                "\n",
+                "import os\n",
+                "\n",
+                "# Set TPU environment variables BEFORE importing torch_xla\n",
+                "os.environ[\"XLA_USE_BF16\"] = \"1\"\n",
+                "os.environ[\"XLA_DOWNCAST_BF16\"] = \"1\"\n",
+                "os.environ[\"PJRT_DEVICE\"] = \"TPU\"\n",
+                "os.environ[\"TOKENIZERS_PARALLELISM\"] = \"false\"\n",
+                "\n",
+                "import torch\n",
+                "import torch_xla\n",
+                "import torch_xla.core.xla_model as xm\n",
+                "import torch_xla.distributed.xla_multiprocessing as xmp\n",
+                "\n",
+                "# Verify TPU\n",
+                "print(\"=\" * 60)\n",
+                "print(\"  TPU Configuration\")\n",
+                "print(\"=\" * 60)\n",
+                "print(f\"  PyTorch version:  {torch.__version__}\")\n",
+                "print(f\"  PyTorch/XLA version: {torch_xla.__version__}\")\n",
+                "\n",
+                "try:\n",
+                "    device = xm.xla_device()\n",
+                "    print(f\"  XLA device:       {device}\")\n",
+                "    print(f\"  World size:       {xm.xrt_world_size()}\")\n",
+                "    \n",
+                "    # Quick computation test\n",
+                "    t = torch.randn(2, 2).to(device)\n",
+                "    result = t @ t.T\n",
+                "    xm.mark_step()\n",
+                "    print(f\"  TPU compute test: ✅ PASSED\")\n",
+                "    print(f\"  TPU dtype:        bfloat16 (native)\")\n",
+                "    print(\"=\" * 60)\n",
+                "    print(\"\\n✅ TPU is ready for training!\")\n",
+                "except Exception as e:\n",
+                "    print(f\"\\n❌ TPU initialization failed: {e}\")\n",
+                "    print(\"Please go to Runtime > Change runtime type > TPU\")\n",
+                "    raise"
+            ],
+            "execution_count": null,
+            "outputs": []
+        },
+        {
+            "cell_type": "markdown",
+            "metadata": {},
+            "source": [
+                "## Cell 2: 📁 Project Setup & Paths"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "metadata": {},
+            "source": [
+                "#@title 2.1 — Configure Paths { display-mode: \"form\" }\n",
+                "import os\n",
+                "\n",
+                "# ══════════════════════════════════════════════════════════\n",
+                "# CONFIGURE THESE PATHS FOR YOUR SETUP\n",
+                "# ══════════════════════════════════════════════════════════\n",
+                "\n",
+                "# Path to the surgery model directory\n",
+                "SURGERY_MODEL_PATH = \"/content/vibevoice_qwen3_surgery\"  #@param {type:\"string\"}\n",
+                "\n",
+                "# Path to the directory containing preprocessed .pt files\n",
+                "# Each .pt file should contain a list of batch dicts\n",
+                "PREPROCESSED_DATA_DIR = \"/content/preprocessed_data\"  #@param {type:\"string\"}\n",
+                "\n",
+                "# Path to the VibeVoice source code\n",
+                "# You need: vibevoice/, vibevoice_surgery_colab.py, tpu_config.py, finetune_vibevoice_tpu.py\n",
+                "PROJECT_DIR = \"/content/VibeVoice/src\"  #@param {type:\"string\"}\n",
+                "\n",
+                "# Output directory for trained artifacts\n",
+                "OUTPUT_DIR = \"/content/vibevoice_tpu_finetuned\"  #@param {type:\"string\"}\n",
+                "\n",
+                "# ══════════════════════════════════════════════════════════\n",
+                "\n",
+                "# Validation\n",
+                "if not os.path.exists(SURGERY_MODEL_PATH):\n",
+                "    print(f\"⚠️  Surgery model not found at: {SURGERY_MODEL_PATH}\")\n",
+                "    print(f\"   Please upload the surgery model or update the path.\")\n",
+                "\n",
+                "if not os.path.exists(PREPROCESSED_DATA_DIR):\n",
+                "    print(f\"⚠️  Preprocessed data not found at: {PREPROCESSED_DATA_DIR}\")\n",
+                "    print(f\"   Please upload .pt files to this directory.\")\n",
+                "else:\n",
+                "    pt_files = [f for f in os.listdir(PREPROCESSED_DATA_DIR) if f.endswith('.pt')]\n",
+                "    print(f\"   Found {len(pt_files)} .pt files in {PREPROCESSED_DATA_DIR}\")\n",
+                "\n",
+                "print(f\"\\n📁 Configuration:\")\n",
+                "print(f\"   Surgery Model:       {SURGERY_MODEL_PATH}\")\n",
+                "print(f\"   Preprocessed Data:   {PREPROCESSED_DATA_DIR}\")\n",
+                "print(f\"   Project Dir:         {PROJECT_DIR}\")\n",
+                "print(f\"   Output Dir:          {OUTPUT_DIR}\")"
+            ],
+            "execution_count": null,
+            "outputs": []
+        },
+        {
+            "cell_type": "code",
+            "metadata": {},
+            "source": [
+                "#@title 2.2 — Clone or Link Project { display-mode: \"form\" }\n",
+                "\n",
+                "import os, sys\n",
+                "\n",
+                "# Option A: If project is in a Git repo\n",
+                "GIT_REPO_URL = \"\"  #@param {type:\"string\"}\n",
+                "\n",
+                "if GIT_REPO_URL and not os.path.exists(PROJECT_DIR):\n",
+                "    !git clone {GIT_REPO_URL} {PROJECT_DIR}\n",
+                "    print(f\"✅ Cloned project from {GIT_REPO_URL}\")\n",
+                "elif not os.path.exists(PROJECT_DIR):\n",
+                "    os.makedirs(PROJECT_DIR, exist_ok=True)\n",
+                "    print(f\"⚠️  Created empty project dir at {PROJECT_DIR}\")\n",
+                "    print(f\"   Please upload vibevoice/, vibevoice_surgery_colab.py, tpu_config.py, finetune_vibevoice_tpu.py\")\n",
+                "else:\n",
+                "    print(f\"✅ Project dir exists: {PROJECT_DIR}\")\n",
+                "\n",
+                "# Add to Python path\n",
+                "if PROJECT_DIR not in sys.path:\n",
+                "    sys.path.insert(0, PROJECT_DIR)\n",
+                "\n",
+                "# Verify critical files\n",
+                "required_files = [\n",
+                "    \"vibevoice/modular/modeling_vibevoice.py\",\n",
+                "    \"vibevoice/modular/configuration_vibevoice.py\",\n",
+                "    \"vibevoice_surgery_colab.py\",\n",
+                "    \"tpu_config.py\",\n",
+                "    \"finetune_vibevoice_tpu.py\",\n",
+                "]\n",
+                "missing = [f for f in required_files if not os.path.exists(os.path.join(PROJECT_DIR, f))]\n",
+                "if missing:\n",
+                "    print(f\"\\n❌ Missing required files:\")\n",
+                "    for f in missing:\n",
+                "        print(f\"   - {f}\")\n",
+                "else:\n",
+                "    print(f\"\\n✅ All required project files found!\")"
+            ],
+            "execution_count": null,
+            "outputs": []
+        },
+        {
+            "cell_type": "markdown",
+            "metadata": {},
+            "source": [
+                "## Cell 3: 📊 Preprocessed Data Validation"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "metadata": {},
+            "source": [
+                "#@title 3.1 — Validate Preprocessed Data { display-mode: \"form\" }\n",
+                "\n",
+                "import os, torch\n",
+                "\n",
+                "def validate_preprocessed_data(data_dir, n_preview=3):\n",
+                "    \"\"\"Validate and preview preprocessed .pt files.\"\"\"\n",
+                "    print(f\"\\n{'='*60}\")\n",
+                "    print(f\"  Preprocessed Data Validation\")\n",
+                "    print(f\"{'='*60}\")\n",
+                "    \n",
+                "    pt_files = sorted([f for f in os.listdir(data_dir) if f.endswith('.pt')])\n",
+                "    \n",
+                "    if not pt_files:\n",
+                "        print(f\"  ❌ No .pt files found in {data_dir}\")\n",
+                "        return\n",
+                "    \n",
+                "    print(f\"  📁 Directory: {data_dir}\")\n",
+                "    print(f\"  📄 Files: {len(pt_files)}\")\n",
+                "    \n",
+                "    total_samples = 0\n",
+                "    expected_keys = {\n",
+                "        'input_ids', 'attention_mask', 'speech_tensors', \n",
+                "        'speech_masks', 'speech_semantic_tensors',\n",
+                "        'acoustic_input_mask', 'acoustic_loss_mask', 'speeches_loss_input'\n",
+                "    }\n",
+                "    \n",
+                "    for i, fname in enumerate(pt_files):\n",
+                "        fpath = os.path.join(data_dir, fname)\n",
+                "        fsize_mb = os.path.getsize(fpath) / (1024 * 1024)\n",
+                "        \n",
+                "        try:\n",
+                "            data = torch.load(fpath, map_location='cpu')\n",
+                "            \n",
+                "            if isinstance(data, list):\n",
+                "                num_samples = len(data)\n",
+                "                total_samples += num_samples\n",
+                "                \n",
+                "                # Validate first sample\n",
+                "                if data and isinstance(data[0], dict):\n",
+                "                    keys = set(data[0].keys())\n",
+                "                    missing_keys = expected_keys - keys\n",
+                "                    extra_keys = keys - expected_keys\n",
+                "                    \n",
+                "                    status = \"✅\" if not missing_keys else \"⚠️\"\n",
+                "                    print(f\"\\n  {status} {fname} ({fsize_mb:.1f} MB): {num_samples} samples\")\n",
+                "                    print(f\"     Keys: {sorted(keys)}\")\n",
+                "                    \n",
+                "                    if missing_keys:\n",
+                "                        print(f\"     ⚠️  Missing keys: {missing_keys}\")\n",
+                "                    \n",
+                "                    # Preview tensor shapes\n",
+                "                    if i < n_preview:\n",
+                "                        sample = data[0]\n",
+                "                        for k, v in sample.items():\n",
+                "                            if isinstance(v, torch.Tensor):\n",
+                "                                print(f\"     {k}: shape={v.shape}, dtype={v.dtype}\")\n",
+                "            elif isinstance(data, dict):\n",
+                "                total_samples += 1\n",
+                "                print(f\"\\n  ✅ {fname} ({fsize_mb:.1f} MB): 1 sample (single dict)\")\n",
+                "                \n",
+                "        except Exception as e:\n",
+                "            print(f\"\\n  ❌ {fname}: Failed to load — {e}\")\n",
+                "    \n",
+                "    print(f\"\\n  {'='*60}\")\n",
+                "    print(f\"  Total samples: {total_samples}\")\n",
+                "    print(f\"  {'='*60}\")\n",
+                "    \n",
+                "    return total_samples\n",
+                "\n",
+                "total_samples = validate_preprocessed_data(PREPROCESSED_DATA_DIR)"
+            ],
+            "execution_count": null,
+            "outputs": []
+        },
+        {
+            "cell_type": "markdown",
+            "metadata": {},
+            "source": [
+                "## Cell 4: 🧊 Configure Freezing Strategy\n",
+                "\n",
+                "### Layer Groups\n",
+                "\n",
+                "| Layer Group | Parameters (approx) | Memory Impact | Description |\n",
+                "|-------------|--------------------|--------------:|-------------|\n",
+                "| **LLM (Qwen3-4B)** | ~4B | ~8 GB bf16 | Language model backbone |\n",
+                "| **Diffusion Head** | ~107M | ~214 MB bf16 | DDPM denoiser |\n",
+                "| **Surgery Module** | ~26M | ~52 MB bf16 | 2560→3584 bridge |\n",
+                "| **Acoustic Connector** | ~0.1M | ~0.2 MB bf16 | 64→2560 projection |\n",
+                "| **Semantic Connector** | ~0.3M | ~0.6 MB bf16 | 128→2560 projection |\n",
+                "| **LM Head** | ~388M | ~776 MB bf16 | Tied to embeddings (frozen) |\n",
+                "\n",
+                "### TPU Memory Budget (per core)\n",
+                "~12 GB model + ~3.5 GB training overhead = ~15.5 GB out of 8 GB per core\n",
+                "\n",
+                "**Note**: With 8 TPU cores, each core processes a separate batch. Total HBM = 64 GB.\n",
+                "The model is **replicated** across all 8 cores (data parallelism)."
+            ]
+        },
+        {
+            "cell_type": "code",
+            "metadata": {},
+            "source": [
+                "#@title 4.1 — Layer Freezing Configuration { display-mode: \"form\" }\n",
+                "\n",
+                "# ══════════════════════════════════════════════════════════\n",
+                "# FREEZING STRATEGY — Choose what to freeze/train\n",
+                "# ══════════════════════════════════════════════════════════\n",
+                "\n",
+                "# For TPU with 8GB per core, default strategy:\n",
+                "# Freeze LLM (use LoRA), freeze diffusion head, train surgery+connectors\n",
+                "\n",
+                "FREEZE_LLM = False    #@param {type:\"boolean\"}  # False = use LoRA on LLM\n",
+                "FREEZE_DIFFUSION_HEAD = True   #@param {type:\"boolean\"}\n",
+                "FREEZE_SURGERY_MODULE = False  #@param {type:\"boolean\"}\n",
+                "FREEZE_CONNECTORS = False      #@param {type:\"boolean\"}\n",
+                "FREEZE_LM_HEAD = True          #@param {type:\"boolean\"}\n",
+                "\n",
+                "# ── LoRA Settings ──\n",
+                "USE_LORA_ON_LLM = True   #@param {type:\"boolean\"}\n",
+                "LORA_R = 8         #@param {type:\"integer\"}\n",
+                "LORA_ALPHA = 32    #@param {type:\"integer\"}\n",
+                "LORA_DROPOUT = 0.05  #@param {type:\"float\"}\n",
+                "\n",
+                "# Configure target modules\n",
+                "if FREEZE_LLM:\n",
+                "    USE_LORA_ON_LLM = False\n",
+                "    LORA_TARGET_MODULES = \"none\"\n",
+                "else:\n",
+                "    LORA_TARGET_MODULES = \"q_proj,k_proj,v_proj,o_proj,gate_proj,up_proj,down_proj\" if USE_LORA_ON_LLM else \"none\"\n",
+                "\n",
+                "# ── Diffusion Head options ──\n",
+                "LORA_WRAP_DIFFUSION_HEAD = False  #@param {type:\"boolean\"}\n",
+                "TRAIN_DIFFUSION_HEAD = False       #@param {type:\"boolean\"}\n",
+                "\n",
+                "# ── Print Summary ──\n",
+                "print(\"=\" * 60)\n",
+                "print(\"  Freezing Strategy\")\n",
+                "print(\"=\" * 60)\n",
+                "components = [\n",
+                "    (\"LLM (Qwen3-4B)\",        FREEZE_LLM,               \"~4B params | ~8 GB\"),\n",
+                "    (\"Diffusion Head\",        FREEZE_DIFFUSION_HEAD,     \"~107M params | ~214 MB\"),\n",
+                "    (\"Surgery Module\",        FREEZE_SURGERY_MODULE,     \"~26M params | ~52 MB\"),\n",
+                "    (\"Acoustic Connector\",    FREEZE_CONNECTORS,         \"~0.1M params | ~0.2 MB\"),\n",
+                "    (\"Semantic Connector\",    FREEZE_CONNECTORS,         \"~0.3M params | ~0.6 MB\"),\n",
+                "    (\"LM Head\",              FREEZE_LM_HEAD,            \"~388M params | ~776 MB\"),\n",
+                "]\n",
+                "\n",
+                "train_count = 0\n",
+                "for name, frozen, params in components:\n",
+                "    status = \"❌ FREEZE\" if frozen else \"✅ TRAIN\"\n",
+                "    print(f\"  {name:<25s} {status:<12s}  {params}\")\n",
+                "    if not frozen:\n",
+                "        train_count += 1\n",
+                "\n",
+                "print(f\"\\n  LoRA on LLM:             {'✅ Yes (r=' + str(LORA_R) + ')' if USE_LORA_ON_LLM else '❌ No'}\")\n",
+                "print(f\"  LoRA on Diffusion Head:  {'✅ Yes' if LORA_WRAP_DIFFUSION_HEAD else '❌ No'}\")\n",
+                "print(f\"  Full Train Diffusion:    {'✅ Yes' if TRAIN_DIFFUSION_HEAD else '❌ No'}\")\n",
+                "print(f\"\\n  Components to train: {train_count}\")\n",
+                "print(\"=\" * 60)"
+            ],
+            "execution_count": null,
+            "outputs": []
+        },
+        {
+            "cell_type": "markdown",
+            "metadata": {},
+            "source": [
+                "## Cell 5: 🚀 Training Configuration"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "metadata": {},
+            "source": [
+                "#@title 5.1 — Hyperparameters { display-mode: \"form\" }\n",
+                "\n",
+                "# ══════════════════════════════════════════════════════════\n",
+                "# TRAINING HYPERPARAMETERS FOR TPU\n",
+                "# ══════════════════════════════════════════════════════════\n",
+                "\n",
+                "MAX_STEPS = 5000             #@param {type:\"integer\"}\n",
+                "NUM_EPOCHS = 3               #@param {type:\"integer\"}\n",
+                "BATCH_SIZE_PER_CORE = 1      #@param {type:\"integer\"}\n",
+                "GRADIENT_ACCUMULATION_STEPS = 8  #@param {type:\"integer\"}\n",
+                "LEARNING_RATE = 2e-5         #@param {type:\"number\"}\n",
+                "LR_SCHEDULER = \"cosine\"      #@param [\"cosine\", \"linear\", \"constant\"]\n",
+                "WARMUP_STEPS = 100           #@param {type:\"integer\"}\n",
+                "WARMUP_RATIO = 0.1           #@param {type:\"number\"}\n",
+                "WEIGHT_DECAY = 0.01          #@param {type:\"number\"}\n",
+                "MAX_GRAD_NORM = 1.0          #@param {type:\"number\"}\n",
+                "\n",
+                "# Loss weights\n",
+                "CE_LOSS_WEIGHT = 1.0         #@param {type:\"number\"}\n",
+                "DIFFUSION_LOSS_WEIGHT = 1.0  #@param {type:\"number\"}\n",
+                "DDPM_BATCH_MUL = 1           #@param {type:\"integer\"}\n",
+                "\n",
+                "# EMA\n",
+                "EMA_DECAY = 0.999            #@param {type:\"number\"}\n",
+                "\n",
+                "# Data\n",
+                "EVAL_SPLIT_SIZE = 0.05       #@param {type:\"number\"}\n",
+                "\n",
+                "# Memory optimization\n",
+                "GRADIENT_CHECKPOINTING = True  #@param {type:\"boolean\"}\n",
+                "\n",
+                "# Logging\n",
+                "LOGGING_STEPS = 10           #@param {type:\"integer\"}\n",
+                "SAVE_STEPS = 500             #@param {type:\"integer\"}\n",
+                "SAVE_TOTAL_LIMIT = 3         #@param {type:\"integer\"}\n",
+                "EVAL_STEPS = 500             #@param {type:\"integer\"}\n",
+                "\n",
+                "# Seed\n",
+                "SEED = 42                    #@param {type:\"integer\"}\n",
+                "\n",
+                "# Compute effective batch size\n",
+                "# On Colab TPU v2, there are 8 cores\n",
+                "NUM_TPU_CORES = 8\n",
+                "effective_batch = BATCH_SIZE_PER_CORE * GRADIENT_ACCUMULATION_STEPS * NUM_TPU_CORES\n",
+                "print(f\"\\n📊 TPU Training Configuration:\")\n",
+                "print(f\"   Max Steps:           {MAX_STEPS}\")\n",
+                "print(f\"   Epochs:              {NUM_EPOCHS}\")\n",
+                "print(f\"   Batch/Core:          {BATCH_SIZE_PER_CORE}\")\n",
+                "print(f\"   Grad Accum:          {GRADIENT_ACCUMULATION_STEPS}\")\n",
+                "print(f\"   TPU Cores:           {NUM_TPU_CORES}\")\n",
+                "print(f\"   Effective Batch:     {effective_batch}\")\n",
+                "print(f\"   Learning Rate:       {LEARNING_RATE}\")\n",
+                "print(f\"   LR Scheduler:        {LR_SCHEDULER}\")\n",
+                "print(f\"   Precision:           bfloat16 (TPU native)\")\n",
+                "print(f\"   Grad Checkpoint:     {GRADIENT_CHECKPOINTING}\")\n",
+                "print(f\"   EMA Decay:           {EMA_DECAY}\")"
+            ],
+            "execution_count": null,
+            "outputs": []
+        },
+        {
+            "cell_type": "markdown",
+            "metadata": {},
+            "source": [
+                "## Cell 6: 🏋️ Launch Fine-Tuning"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "metadata": {},
+            "source": [
+                "#@title 6.1 — Pre-Training Checks { display-mode: \"form\" }\n",
+                "\n",
+                "import os, sys, torch\n",
+                "\n",
+                "print(\"🔍 Pre-training checks:\")\n",
+                "\n",
+                "errors = []\n",
+                "\n",
+                "# Check surgery model\n",
+                "if not os.path.exists(SURGERY_MODEL_PATH):\n",
+                "    errors.append(f\"Surgery model not found: {SURGERY_MODEL_PATH}\")\n",
+                "else:\n",
+                "    config_path = os.path.join(SURGERY_MODEL_PATH, \"config.json\")\n",
+                "    if os.path.exists(config_path):\n",
+                "        print(f\"  ✅ Surgery model config found\")\n",
+                "    else:\n",
+                "        errors.append(f\"config.json not found in {SURGERY_MODEL_PATH}\")\n",
+                "\n",
+                "# Check preprocessed data\n",
+                "if not os.path.exists(PREPROCESSED_DATA_DIR):\n",
+                "    errors.append(f\"Preprocessed data dir not found: {PREPROCESSED_DATA_DIR}\")\n",
+                "else:\n",
+                "    pt_files = [f for f in os.listdir(PREPROCESSED_DATA_DIR) if f.endswith('.pt')]\n",
+                "    if not pt_files:\n",
+                "        errors.append(f\"No .pt files found in {PREPROCESSED_DATA_DIR}\")\n",
+                "    else:\n",
+                "        print(f\"  ✅ Found {len(pt_files)} preprocessed .pt files\")\n",
+                "\n",
+                "# Check TPU\n",
+                "try:\n",
+                "    import torch_xla.core.xla_model as xm\n",
+                "    device = xm.xla_device()\n",
+                "    print(f\"  ✅ TPU device: {device}\")\n",
+                "    print(f\"  ✅ TPU cores: {xm.xrt_world_size()}\")\n",
+                "except Exception as e:\n",
+                "    errors.append(f\"TPU not available: {e}\")\n",
+                "\n",
+                "# Check project files\n",
+                "required_files = [\n",
+                "    \"tpu_config.py\",\n",
+                "    \"finetune_vibevoice_tpu.py\",\n",
+                "    \"vibevoice/modular/modeling_vibevoice.py\",\n",
+                "    \"vibevoice_surgery_colab.py\",\n",
+                "]\n",
+                "for f in required_files:\n",
+                "    fpath = os.path.join(PROJECT_DIR, f)\n",
+                "    if os.path.exists(fpath):\n",
+                "        print(f\"  ✅ {f}\")\n",
+                "    else:\n",
+                "        errors.append(f\"Missing: {f}\")\n",
+                "\n",
+                "if errors:\n",
+                "    print(f\"\\n❌ ERRORS (fix before training):\")\n",
+                "    for e in errors:\n",
+                "        print(f\"   - {e}\")\n",
+                "    raise RuntimeError(\"Pre-training checks failed. See errors above.\")\n",
+                "\n",
+                "print(\"\\n✅ All checks passed! Ready to start training.\")"
+            ],
+            "execution_count": null,
+            "outputs": []
+        },
+        {
+            "cell_type": "code",
+            "metadata": {},
+            "source": [
+                "#@title 6.2 — Execute TPU Fine-Tuning { display-mode: \"form\" }\n",
+                "\n",
+                "import os, sys, subprocess\n",
+                "\n",
+                "# Change to project directory\n",
+                "os.chdir(PROJECT_DIR)\n",
+                "\n",
+                "# Build the training command\n",
+                "cmd = f\"\"\"\n",
+                "python finetune_vibevoice_tpu.py \\\n",
+                "    --model_name_or_path \"{SURGERY_MODEL_PATH}\" \\\n",
+                "    --preprocessed_dir \"{PREPROCESSED_DATA_DIR}\" \\\n",
+                "    --output_dir \"{OUTPUT_DIR}\" \\\n",
+                "    --max_steps {MAX_STEPS} \\\n",
+                "    --num_train_epochs {NUM_EPOCHS} \\\n",
+                "    --per_device_train_batch_size {BATCH_SIZE_PER_CORE} \\\n",
+                "    --gradient_accumulation_steps {GRADIENT_ACCUMULATION_STEPS} \\\n",
+                "    --learning_rate {LEARNING_RATE} \\\n",
+                "    --lr_scheduler_type {LR_SCHEDULER} \\\n",
+                "    --warmup_steps {WARMUP_STEPS} \\\n",
+                "    --warmup_ratio {WARMUP_RATIO} \\\n",
+                "    --max_grad_norm {MAX_GRAD_NORM} \\\n",
+                "    --ce_loss_weight {CE_LOSS_WEIGHT} \\\n",
+                "    --diffusion_loss_weight {DIFFUSION_LOSS_WEIGHT} \\\n",
+                "    --ddpm_batch_mul {DDPM_BATCH_MUL} \\\n",
+                "    --ema_decay {EMA_DECAY} \\\n",
+                "    --eval_split_size {EVAL_SPLIT_SIZE} \\\n",
+                "    --logging_steps {LOGGING_STEPS} \\\n",
+                "    --save_steps {SAVE_STEPS} \\\n",
+                "    --save_total_limit {SAVE_TOTAL_LIMIT} \\\n",
+                "    --eval_steps {EVAL_STEPS} \\\n",
+                "    --lora_r {LORA_R} \\\n",
+                "    --lora_alpha {LORA_ALPHA} \\\n",
+                "    --lora_dropout {LORA_DROPOUT} \\\n",
+                "    --lora_target_modules {LORA_TARGET_MODULES} \\\n",
+                "    --lora_wrap_diffusion_head {str(LORA_WRAP_DIFFUSION_HEAD).lower()} \\\n",
+                "    --train_diffusion_head {str(TRAIN_DIFFUSION_HEAD).lower()} \\\n",
+                "    --train_connectors {str(not FREEZE_CONNECTORS).lower()} \\\n",
+                "    --train_surgery_module {str(not FREEZE_SURGERY_MODULE).lower()} \\\n",
+                "    {'--freeze_llm' if FREEZE_LLM else '--no_freeze_llm'} \\\n",
+                "    {'--freeze_diffusion_head' if FREEZE_DIFFUSION_HEAD else '--no_freeze_diffusion_head'} \\\n",
+                "    {'--freeze_surgery_module' if FREEZE_SURGERY_MODULE else ''} \\\n",
+                "    {'--freeze_connectors' if FREEZE_CONNECTORS else ''} \\\n",
+                "    {'--gradient_checkpointing' if GRADIENT_CHECKPOINTING else '--no_gradient_checkpointing'} \\\n",
+                "    --seed {SEED}\n",
+                "\"\"\"\n",
+                "\n",
+                "# Clean up\n",
+                "import re\n",
+                "cmd = re.sub(r'\\s+\\\\\\n\\s+', ' ', cmd)\n",
+                "cmd = cmd.strip()\n",
+                "\n",
+                "print(\"=\" * 60)\n",
+                "print(\"  Training Command\")\n",
+                "print(\"=\" * 60)\n",
+                "print(cmd)\n",
+                "print(\"=\" * 60)\n",
+                "\n",
+                "print(\"\\n🚀 Starting TPU fine-tuning...\")\n",
+                "print(\"\"\"\n",
+                "NOTE: The first training step will be SLOW due to XLA compilation.\n",
+                "This is normal — subsequent steps will be much faster.\n",
+                "\n",
+                "Monitor the output for:\n",
+                "  - ce_loss: Cross-entropy loss on text tokens\n",
+                "  - diffusion_loss: MSE loss on speech generation\n",
+                "  - total_loss: Combined loss\n",
+                "  - LR: Learning rate schedule\n",
+                "\"\"\")\n",
+                "print(\"=\" * 60)\n",
+                "\n",
+                "# Execute\n",
+                "process = subprocess.Popen(\n",
+                "    cmd,\n",
+                "    shell=True,\n",
+                "    stdout=subprocess.PIPE,\n",
+                "    stderr=subprocess.STDOUT,\n",
+                "    universal_newlines=True,\n",
+                "    bufsize=1,\n",
+                ")\n",
+                "\n",
+                "# Stream output\n",
+                "for line in process.stdout:\n",
+                "    print(line, end='')\n",
+                "\n",
+                "process.wait()\n",
+                "exit_code = process.returncode\n",
+                "\n",
+                "print(\"\\n\" + \"=\" * 60)\n",
+                "if exit_code == 0:\n",
+                "    print(\"✅ TPU Fine-Tuning completed successfully!\")\n",
+                "else:\n",
+                "    print(f\"❌ Training failed with exit code: {exit_code}\")\n",
+                "print(\"=\" * 60)"
+            ],
+            "execution_count": null,
+            "outputs": []
+        },
+        {
+            "cell_type": "markdown",
+            "metadata": {},
+            "source": [
+                "## Cell 7: 📈 Monitor Training & Check Results"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "metadata": {},
+            "source": [
+                "#@title 7.1 — Check Training Progress { display-mode: \"form\" }\n",
+                "\n",
+                "import os, glob, torch\n",
+                "\n",
+                "print(\"=\" * 60)\n",
+                "print(\"  Training Progress\")\n",
+                "print(\"=\" * 60)\n",
+                "\n",
+                "# Check checkpoints\n",
+                "checkpoints = sorted(glob.glob(os.path.join(OUTPUT_DIR, \"checkpoint-*\")), \n",
+                "                      key=lambda x: int(x.split('-')[-1]))\n",
+                "print(f\"\\n📦 Checkpoints saved: {len(checkpoints)}\")\n",
+                "for ckpt in checkpoints[-5:]:\n",
+                "    step = ckpt.split('-')[-1]\n",
+                "    lora_dir = os.path.join(ckpt, \"lora\")\n",
+                "    has_lora = os.path.exists(lora_dir)\n",
+                "    print(f\"  checkpoint-{step} | LoRA: {'✅' if has_lora else '❌'}\")\n",
+                "\n",
+                "# Check final model\n",
+                "final_dir = os.path.join(OUTPUT_DIR, \"final_model\")\n",
+                "if os.path.exists(final_dir):\n",
+                "    print(f\"\\n✅ Final model saved at: {final_dir}\")\n",
+                "else:\n",
+                "    print(f\"\\n⚠️  Final model not yet saved.\")\n",
+                "\n",
+                "# Show disk usage\n",
+                "total_size = 0\n",
+                "for root, dirs, files in os.walk(OUTPUT_DIR):\n",
+                "    for f in files:\n",
+                "        total_size += os.path.getsize(os.path.join(root, f))\n",
+                "print(f\"\\n💾 Total output size: {total_size / 1024 / 1024:.1f} MB\")\n",
+                "print(\"=\" * 60)"
+            ],
+            "execution_count": null,
+            "outputs": []
+        },
+        {
+            "cell_type": "code",
+            "metadata": {},
+            "source": [
+                "#@title 7.2 — Inspect Latest Saved Artifacts { display-mode: \"form\" }\n",
+                "\n",
+                "import os, glob\n",
+                "\n",
+                "# Find latest checkpoint or final model\n",
+                "checkpoints = sorted(glob.glob(os.path.join(OUTPUT_DIR, \"checkpoint-*\")),\n",
+                "                      key=lambda x: int(x.split('-')[-1]))\n",
+                "\n",
+                "latest_dir = checkpoints[-1] if checkpoints else OUTPUT_DIR\n",
+                "lora_dir = os.path.join(latest_dir, \"lora\")\n",
+                "\n",
+                "if not os.path.exists(lora_dir):\n",
+                "    # Try final model\n",
+                "    lora_dir = os.path.join(OUTPUT_DIR, \"final_model\", \"lora\")\n",
+                "    if not os.path.exists(lora_dir):\n",
+                "        print(f\"⚠️  No saved artifacts found.\")\n",
+                "        lora_dir = None\n",
+                "\n",
+                "if lora_dir and os.path.exists(lora_dir):\n",
+                "    print(\"=\" * 60)\n",
+                "    print(f\"  Saved Artifacts: {lora_dir}\")\n",
+                "    print(\"=\" * 60)\n",
+                "    \n",
+                "    for root, dirs, files in os.walk(lora_dir):\n",
+                "        level = root.replace(lora_dir, '').count(os.sep)\n",
+                "        indent = '  ' * level\n",
+                "        print(f'{indent}{os.path.basename(root)}/')\n",
+                "        subindent = '  ' * (level + 1)\n",
+                "        for file in sorted(files):\n",
+                "            fpath = os.path.join(root, file)\n",
+                "            size_mb = os.path.getsize(fpath) / 1024 / 1024\n",
+                "            print(f'{subindent}{file} ({size_mb:.2f} MB)')\n",
+                "    \n",
+                "    print(\"=\" * 60)"
+            ],
+            "execution_count": null,
+            "outputs": []
+        },
+        {
+            "cell_type": "markdown",
+            "metadata": {},
+            "source": [
+                "## Cell 8: 🔄 Phase 2 — Expand Training (Optional)\n",
+                "\n",
+                "After Phase 1 converges, you can expand training to include the diffusion head."
+            ]
+        },
+        {
+            "cell_type": "code",
+            "metadata": {},
+            "source": [
+                "#@title 8.1 — Configure Phase 2 { display-mode: \"form\" }\n",
+                "\n",
+                "# ════════════════════��═════════════════════════════════════\n",
+                "# PHASE 2: Expand training scope\n",
+                "# ══════════════════════════════════════════════════════════\n",
+                "\n",
+                "RUN_PHASE_2 = False  #@param {type:\"boolean\"}\n",
+                "\n",
+                "# Phase 2 settings — keep LLM frozen with LoRA, unfreeze diffusion head with LoRA\n",
+                "P2_FREEZE_LLM = False\n",
+                "P2_FREEZE_DIFFUSION_HEAD = False   # Unfreeze diffusion head!\n",
+                "P2_FREEZE_SURGERY_MODULE = False\n",
+                "P2_FREEZE_CONNECTORS = False\n",
+                "P2_LORA_WRAP_DIFFUSION_HEAD = True  # Use LoRA on head to save memory\n",
+                "P2_LEARNING_RATE = 1e-5  # Lower LR for Phase 2\n",
+                "P2_MAX_STEPS = 3000\n",
+                "\n",
+                "# Resume from Phase 1 checkpoint\n",
+                "P2_RESUME_FROM = os.path.join(OUTPUT_DIR, \"final_model\")  #@param {type:\"string\"}\n",
+                "P2_OUTPUT_DIR = OUTPUT_DIR + \"_phase2\"\n",
+                "\n",
+                "if RUN_PHASE_2:\n",
+                "    print(\"📋 Phase 2 Configuration:\")\n",
+                "    print(f\"   LLM:          {'FROZEN' if P2_FREEZE_LLM else 'LoRA TRAIN'}\")\n",
+                "    print(f\"   Diff. Head:   {'FROZEN' if P2_FREEZE_DIFFUSION_HEAD else 'LoRA TRAIN'}\")\n",
+                "    print(f\"   Surgery Mod:  {'FROZEN' if P2_FREEZE_SURGERY_MODULE else 'TRAIN'}\")\n",
+                "    print(f\"   Connectors:   {'FROZEN' if P2_FREEZE_CONNECTORS else 'TRAIN'}\")\n",
+                "    print(f\"   Head LoRA:    {'Yes' if P2_LORA_WRAP_DIFFUSION_HEAD else 'No'}\")\n",
+                "    print(f\"   LR:           {P2_LEARNING_RATE}\")\n",
+                "    print(f\"   Resume from:  {P2_RESUME_FROM}\")\n",
+                "else:\n",
+                "    print(\"Phase 2 is disabled. Set RUN_PHASE_2=True to enable.\")"
+            ],
+            "execution_count": null,
+            "outputs": []
+        },
+        {
+            "cell_type": "code",
+            "metadata": {},
+            "source": [
+                "#@title 8.2 — Execute Phase 2 { display-mode: \"form\" }\n",
+                "\n",
+                "if RUN_PHASE_2:\n",
+                "    os.chdir(PROJECT_DIR)\n",
+                "    \n",
+                "    p2_cmd = f\"\"\"\n",
+                "    python finetune_vibevoice_tpu.py \\\n",
+                "        --model_name_or_path \"{SURGERY_MODEL_PATH}\" \\\n",
+                "        --preprocessed_dir \"{PREPROCESSED_DATA_DIR}\" \\\n",
+                "        --output_dir \"{P2_OUTPUT_DIR}\" \\\n",
+                "        --resume_from_checkpoint \"{P2_RESUME_FROM}\" \\\n",
+                "        --max_steps {P2_MAX_STEPS} \\\n",
+                "        --num_train_epochs 2 \\\n",
+                "        --per_device_train_batch_size {BATCH_SIZE_PER_CORE} \\\n",
+                "        --gradient_accumulation_steps {GRADIENT_ACCUMULATION_STEPS} \\\n",
+                "        --learning_rate {P2_LEARNING_RATE} \\\n",
+                "        --lr_scheduler_type cosine \\\n",
+                "        --warmup_steps {WARMUP_STEPS} \\\n",
+                "        --max_grad_norm {MAX_GRAD_NORM} \\\n",
+                "        --ce_loss_weight {CE_LOSS_WEIGHT} \\\n",
+                "        --diffusion_loss_weight {DIFFUSION_LOSS_WEIGHT} \\\n",
+                "        --ddpm_batch_mul {DDPM_BATCH_MUL} \\\n",
+                "        --ema_decay {EMA_DECAY} \\\n",
+                "        --eval_split_size {EVAL_SPLIT_SIZE} \\\n",
+                "        --logging_steps {LOGGING_STEPS} \\\n",
+                "        --save_steps {SAVE_STEPS} \\\n",
+                "        --save_total_limit {SAVE_TOTAL_LIMIT} \\\n",
+                "        --eval_steps {EVAL_STEPS} \\\n",
+                "        --lora_r {LORA_R} \\\n",
+                "        --lora_alpha {LORA_ALPHA} \\\n",
+                "        --lora_target_modules q_proj,k_proj,v_proj,o_proj,gate_proj,up_proj,down_proj \\\n",
+                "        --lora_wrap_diffusion_head {str(P2_LORA_WRAP_DIFFUSION_HEAD).lower()} \\\n",
+                "        --train_diffusion_head {str(not P2_FREEZE_DIFFUSION_HEAD).lower()} \\\n",
+                "        --train_connectors {str(not P2_FREEZE_CONNECTORS).lower()} \\\n",
+                "        --train_surgery_module {str(not P2_FREEZE_SURGERY_MODULE).lower()} \\\n",
+                "        {'--no_freeze_llm' if not P2_FREEZE_LLM else '--freeze_llm'} \\\n",
+                "        {'--no_freeze_diffusion_head' if not P2_FREEZE_DIFFUSION_HEAD else '--freeze_diffusion_head'} \\\n",
+                "        --gradient_checkpointing \\\n",
+                "        --seed {SEED}\n",
+                "    \"\"\"\n",
+                "    \n",
+                "    import re\n",
+                "    p2_cmd = re.sub(r'\\s+\\\\\\n\\s+', ' ', p2_cmd).strip()\n",
+                "    \n",
+                "    print(\"🚀 Starting Phase 2 training on TPU...\")\n",
+                "    \n",
+                "    process = subprocess.Popen(p2_cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, universal_newlines=True, bufsize=1)\n",
+                "    for line in process.stdout:\n",
+                "        print(line, end='')\n",
+                "    process.wait()\n",
+                "    \n",
+                "    if process.returncode == 0:\n",
+                "        print(\"\\n✅ Phase 2 training completed!\")\n",
+                "    else:\n",
+                "        print(f\"\\n❌ Phase 2 failed with exit code: {process.returncode}\")\n",
+                "else:\n",
+                "    print(\"Phase 2 skipped (RUN_PHASE_2=False).\")"
+            ],
+            "execution_count": null,
+            "outputs": []
+        },
+        {
+            "cell_type": "markdown",
+            "metadata": {},
+            "source": [
+                "## Cell 9: 💾 Export & Merge Trained Weights"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "metadata": {},
+            "source": [
+                "#@title 9.1 — Merge LoRA Weights & Create Inference Model { display-mode: \"form\" }\n",
+                "\n",
+                "import os, sys, gc, torch\n",
+                "\n",
+                "os.chdir(PROJECT_DIR)\n",
+                "sys.path.insert(0, PROJECT_DIR)\n",
+                "\n",
+                "MERGE_OUTPUT = os.path.join(OUTPUT_DIR, \"merged_inference\")  #@param {type:\"string\"}\n",
+                "\n",
+                "print(\"=\" * 60)\n",
+                "print(\"  Merging Trained Weights (TPU → CPU for inference)\")\n",
+                "print(\"=\" * 60)\n",
+                "\n",
+                "# Find the checkpoint with trained weights\n",
+                "# Try final_model first, then latest checkpoint\n",
+                "lora_dir = os.path.join(OUTPUT_DIR, \"final_model\", \"lora\")\n",
+                "if not os.path.exists(lora_dir):\n",
+                "    checkpoints = sorted(glob.glob(os.path.join(OUTPUT_DIR, \"checkpoint-*\")),\n",
+                "                          key=lambda x: int(x.split('-')[-1]))\n",
+                "    if checkpoints:\n",
+                "        lora_dir = os.path.join(checkpoints[-1], \"lora\")\n",
+                "\n",
+                "if not os.path.exists(lora_dir):\n",
+                "    raise FileNotFoundError(f\"No trained artifacts found in {OUTPUT_DIR}\")\n",
+                "\n",
+                "print(f\"\\nUsing trained weights from: {lora_dir}\")\n",
+                "\n",
+                "# Apply patches\n",
+                "from vibevoice_surgery_colab import (\n",
+                "    _patch_vibevoice_config_for_qwen3,\n",
+                "    Qwen3SurgeryModule,\n",
+                "    load_surgery_model,\n",
+                "    save_surgery_model,\n",
+                "    QWEN3_HIDDEN_SIZE,\n",
+                "    DIFFUSION_HIDDEN_SIZE,\n",
+                "    SURGERY_LAYER_INDICES,\n",
+                ")\n",
+                "_patch_vibevoice_config_for_qwen3()\n",
+                "\n",
+                "# Load the base surgery model\n",
+                "print(\"\\n[1/5] Loading base surgery model...\")\n",
+                "model = load_surgery_model(SURGERY_MODEL_PATH, dtype=torch.float32, device_map=\"cpu\")\n",
+                "\n",
+                "# Load LLM LoRA weights\n",
+                "print(\"\\n[2/5] Loading LLM LoRA weights...\")\n",
+                "try:\n",
+                "    from peft import load_peft_weights, set_peft_model_state_dict\n",
+                "    adapters_weights = load_peft_weights(lora_dir)\n",
+                "    set_peft_model_state_dict(model.model.language_model, adapters_weights)\n",
+                "    model.model.language_model = model.model.language_model.merge_and_unload()\n",
+                "    print(\"  ✅ LLM LoRA merged\")\n",
+                "except Exception as e:\n",
+                "    print(f\"  ℹ️  No LLM LoRA found: {e}\")\n",
+                "\n",
+                "# Load Diffusion Head\n",
+                "print(\"\\n[3/5] Loading Diffusion Head weights...\")\n",
+                "ph_path = os.path.join(lora_dir, \"diffusion_head_full.bin\")\n",
+                "if os.path.exists(ph_path):\n",
+                "    model.model.prediction_head.load_state_dict(\n",
+                "        torch.load(ph_path, map_location=\"cpu\"), strict=False\n",
+                "    )\n",
+                "    print(\"  ✅ Diffusion Head loaded\")\n",
+                "\n",
+                "# Load Connectors\n",
+                "print(\"\\n[4/5] Loading Connectors...\")\n",
+                "for conn_name in [\"acoustic_connector\", \"semantic_connector\"]:\n",
+                "    conn_path = os.path.join(lora_dir, conn_name, \"pytorch_model.bin\")\n",
+                "    conn = getattr(model.model, conn_name, None)\n",
+                "    if os.path.exists(conn_path) and conn is not None:\n",
+                "        conn.load_state_dict(torch.load(conn_path, map_location=\"cpu\"))\n",
+                "        print(f\"  ✅ {conn_name} loaded\")\n",
+                "\n",
+                "# Load Surgery Module\n",
+                "print(\"\\n[5/5] Loading Surgery Module...\")\n",
+                "sm_path = os.path.join(lora_dir, \"surgery_module\", \"pytorch_model.bin\")\n",
+                "if os.path.exists(sm_path) and hasattr(model.model, \"surgery_module\"):\n",
+                "    model.model.surgery_module.load_state_dict(\n",
+                "        torch.load(sm_path, map_location=\"cpu\")\n",
+                "    )\n",
+                "    print(\"  ✅ Surgery Module loaded\")\n",
+                "\n",
+                "# Save merged model\n",
+                "print(f\"\\n💾 Saving merged model to {MERGE_OUTPUT}...\")\n",
+                "save_surgery_model(model, MERGE_OUTPUT)\n",
+                "print(f\"\\n✅ Merged inference model saved to: {MERGE_OUTPUT}\")\n",
+                "\n",
+                "# Cleanup\n",
+                "del model\n",
+                "gc.collect()"
+            ],
+            "execution_count": null,
+            "outputs": []
+        },
+        {
+            "cell_type": "markdown",
+            "metadata": {},
+            "source": [
+                "## Cell 10: 🎤 Quick Inference Test"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "metadata": {},
+            "source": [
+                "#@title 10.1 — Load Merged Model for Inference { display-mode: \"form\" }\n",
+                "\n",
+                "import os, sys, gc, torch\n",
+                "\n",
+                "os.chdir(PROJECT_DIR)\n",
+                "sys.path.insert(0, PROJECT_DIR)\n",
+                "\n",
+                "from vibevoice_surgery_colab import (\n",
+                "    _patch_vibevoice_config_for_qwen3,\n",
+                "    load_surgery_model,\n",
+                ")\n",
+                "_patch_vibevoice_config_for_qwen3()\n",
+                "\n",
+                "MERGE_PATH = os.path.join(OUTPUT_DIR, \"merged_inference\")\n",
+                "\n",
+                "if not os.path.exists(MERGE_PATH):\n",
+                "    print(f\"⚠️  Merged model not found at {MERGE_PATH}\")\n",
+                "    print(f\"   Using base surgery model instead.\")\n",
+                "    MERGE_PATH = SURGERY_MODEL_PATH\n",
+                "\n",
+                "print(f\"Loading model from {MERGE_PATH}...\")\n",
+                "# For inference, use CPU or GPU (not TPU — inference is better on GPU)\n",
+                "inference_device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
+                "print(f\"Inference device: {inference_device}\")\n",
+                "\n",
+                "inference_model = load_surgery_model(\n",
+                "    MERGE_PATH,\n",
+                "    dtype=torch.float16 if inference_device == \"cuda\" else torch.float32,\n",
+                "    device_map=\"auto\" if inference_device == \"cuda\" else \"cpu\",\n",
+                ")\n",
+                "inference_model.eval()\n",
+                "print(\"✅ Model loaded for inference!\")"
+            ],
+            "execution_count": null,
+            "outputs": []
+        },
+        {
+            "cell_type": "code",
+            "metadata": {},
+            "source": [
+                "#@title 10.2 — Generate Speech { display-mode: \"form\" }\n",
+                "\n",
+                "import torch\n",
+                "\n",
+                "TEXT_TO_SPEAK = \"Hello, this is a test of the fine-tuned voice model.\"  #@param {type:\"string\"}\n",
+                "VOICE_PROMPT_PATH = \"\"  #@param {type:\"string\"}\n",
+                "CFG_SCALE = 3.0  #@param {type:\"number\"}\n",
+                "OUTPUT_AUDIO_PATH = \"/content/generated_speech.wav\"  #@param {type:\"string\"}\n",
+                "\n",
+                "from vibevoice.processor.vibevoice_processor import VibeVoiceProcessor\n",
+                "\n",
+                "# Load processor\n",
+                "processor = VibeVoiceProcessor.from_pretrained(MERGE_PATH)\n",
+                "\n",
+                "# Prepare inputs\n",
+                "if VOICE_PROMPT_PATH and os.path.exists(VOICE_PROMPT_PATH):\n",
+                "    proc_out = processor(\n",
+                "        text=[TEXT_TO_SPEAK],\n",
+                "        voice_samples=[[VOICE_PROMPT_PATH]],\n",
+                "        return_tensors=\"pt\",\n",
+                "    )\n",
+                "else:\n",
+                "    proc_out = processor(\n",
+                "        text=[TEXT_TO_SPEAK],\n",
+                "        return_tensors=\"pt\",\n",
+                "    )\n",
+                "\n",
+                "input_ids = proc_out[\"input_ids\"]\n",
+                "attention_mask = proc_out.get(\"attention_mask\", torch.ones_like(input_ids))\n",
+                "\n",
+                "# Move to device\n",
+                "device = next(inference_model.parameters()).device\n",
+                "input_ids = input_ids.to(device)\n",
+                "attention_mask = attention_mask.to(device)\n",
+                "\n",
+                "speech_tensors = proc_out.get(\"speech_tensors\")\n",
+                "speech_masks = proc_out.get(\"speech_masks\")\n",
+                "speech_input_mask = proc_out.get(\"speech_input_mask\")\n",
+                "\n",
+                "if speech_tensors is not None:\n",
+                "    speech_tensors = speech_tensors.to(device)\n",
+                "if speech_masks is not None:\n",
+                "    speech_masks = speech_masks.to(device)\n",
+                "if speech_input_mask is not None:\n",
+                "    speech_input_mask = speech_input_mask.to(device)\n",
+                "\n",
+                "print(f\"Generating speech for: {TEXT_TO_SPEAK[:80]}...\")\n",
+                "print(f\"Input shape: {input_ids.shape}\")\n",
+                "\n",
+                "# Generate\n",
+                "with torch.no_grad():\n",
+                "    output = inference_model.generate(\n",
+                "        input_ids=input_ids,\n",
+                "        attention_mask=attention_mask,\n",
+                "        speech_tensors=speech_tensors,\n",
+                "        speech_masks=speech_masks,\n",
+                "        speech_input_mask=speech_input_mask,\n",
+                "        max_new_tokens=2048,\n",
+                "        cfg_scale=CFG_SCALE,\n",
+                "        return_speech=True,\n",
+                "    )\n",
+                "\n",
+                "# Extract audio\n",
+                "if hasattr(output, 'speech_outputs') and output.speech_outputs:\n",
+                "    import soundfile as sf\n",
+                "    audio = output.speech_outputs[0]\n",
+                "    if isinstance(audio, torch.Tensor):\n",
+                "        audio = audio.cpu().numpy()\n",
+                "    sf.write(OUTPUT_AUDIO_PATH, audio, 24000)\n",
+                "    print(f\"\\n✅ Audio saved to {OUTPUT_AUDIO_PATH}\")\n",
+                "    \n",
+                "    # Play in Colab\n",
+                "    from IPython.display import Audio, display\n",
+                "    display(Audio(OUTPUT_AUDIO_PATH))\n",
+                "else:\n",
+                "    print(\"⚠️  No speech output generated.\")\n",
+                "    print(\"Output type:\", type(output))\n",
+                "    if hasattr(output, 'sequences'):\n",
+                "        print(f\"Generated sequence shape: {output.sequences.shape}\")"
+            ],
+            "execution_count": null,
+            "outputs": []
+        },
+        {
+            "cell_type": "markdown",
+            "metadata": {},
+            "source": [
+                "## Cell 11: 📦 Download Results"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "metadata": {},
+            "source": [
+                "#@title 11.1 — Zip and Download Trained Artifacts { display-mode: \"form\" }\n",
+                "\n",
+                "import os, shutil\n",
+                "\n",
+                "ZIP_NAME = \"vibevoice_tpu_finetuned.zip\"  #@param {type:\"string\"}\n",
+                "\n",
+                "zip_path = f\"/content/{ZIP_NAME}\"\n",
+                "\n",
+                "# Create zip\n",
+                "print(f\"📦 Creating zip archive: {ZIP_NAME}...\")\n",
+                "shutil.make_archive(\n",
+                "    zip_path.replace('.zip', ''),\n",
+                "    'zip',\n",
+                "    os.path.dirname(OUTPUT_DIR),\n",
+                "    os.path.basename(OUTPUT_DIR)\n",
+                ")\n",
+                "\n",
+                "size_mb = os.path.getsize(zip_path) / (1024 * 1024)\n",
+                "print(f\"✅ Archive created: {zip_path} ({size_mb:.1f} MB)\")\n",
+                "\n",
+                "# Download\n",
+                "from google.colab import files\n",
+                "print(f\"\\n📥 Downloading {ZIP_NAME}...\")\n",
+                "files.download(zip_path)"
+            ],
+            "execution_count": null,
+            "outputs": []
+        },
+        {
+            "cell_type": "code",
+            "metadata": {},
+            "source": [
+                "#@title 11.2 — Upload to Google Drive { display-mode: \"form\" }\n",
+                "\n",
+                "UPLOAD_TO_DRIVE = False  #@param {type:\"boolean\"}\n",
+                "DRIVE_PATH = \"/content/drive/MyDrive/vibevoice_tpu_finetuned\"  #@param {type:\"string\"}\n",
+                "\n",
+                "if UPLOAD_TO_DRIVE:\n",
+                "    from google.colab import drive\n",
+                "    drive.mount('/content/drive')\n",
+                "    \n",
+                "    import shutil\n",
+                "    print(f\"📤 Copying to Google Drive: {DRIVE_PATH}...\")\n",
+                "    if os.path.exists(DRIVE_PATH):\n",
+                "        shutil.rmtree(DRIVE_PATH)\n",
+                "    shutil.copytree(OUTPUT_DIR, DRIVE_PATH)\n",
+                "    print(f\"✅ Copied to {DRIVE_PATH}\")\n",
+                "else:\n",
+                "    print(\"Drive upload skipped. Set UPLOAD_TO_DRIVE=True to enable.\")"
+            ],
+            "execution_count": null,
+            "outputs": []
+        }
+    ]
+}

VibeVoice-tpu/src/preprocess_vibevoice.py

@@ -0,0 +1,192 @@
+"""
+VibeVoice Dataset Preprocessing Script
+
+این اسکریپت تمام داده‌ها را روی GPU پردازش کرده و نتایج را در یک فایل .pt ذخیره می‌کند.
+در حین آموزش، داده‌های پردازش شده از حافظه یا دیسک بارگذاری می‌شوند.
+
+استفاده:
+    python preprocess_vibevoice.py \\
+        --processor_name_or_path vibevoice/processor \\
+        --train_jsonl final.jsonl \\
+        --output_dir preprocessed_data \\
+        --per_device_batch_size 4 \\
+        --device cuda:0 \\
+        --max_length 800
+
+این تمام داده‌ها را از .jsonl می‌خواند، بر روی GPU پردازش می‌کند و خروجی را
+به صورت مجموعه‌ای از فایل‌های PyTorch ذخیره می‌کند.
+"""
+
+import logging
+import json
+import os
+import torch
+import numpy as np
+from pathlib import Path
+from dataclasses import dataclass
+from typing import Optional, Dict, Any, List
+from tqdm import tqdm
+
+from transformers import HfArgumentParser
+from vibevoice.processor.vibevoice_processor import VibeVoiceProcessor
+from data_vibevoice import _load_audio_to_24k, VibeVoiceCollator
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class PreprocessArguments:
+    """Arguments for preprocessing"""
+    processor_name_or_path: Optional[str] = None
+    train_jsonl: Optional[str] = None
+    output_dir: str = "preprocessed_data"
+    per_device_batch_size: int = 4
+    device: str = "cuda:0"
+    max_length: Optional[int] = None
+    text_column_name: str = "text"
+    audio_column_name: str = "audio"
+    voice_prompts_column_name: str = "voice_prompts"
+    save_raw_audio: bool = False  # اگر True باشد، صوت خام را نیز ذخیره کند
+    debug: bool = False
+
+
+class RawDatasetLoader:
+    """سادگی‌تر نسخه‌ای از VibeVoiceDataset برای پردازش خام"""
+    def __init__(self, jsonl_path: str, text_column: str = "text", 
+                 audio_column: str = "audio", voice_prompts_column: str = "voice_prompts"):
+        self.jsonl_path = jsonl_path
+        self.text_column = text_column
+        self.audio_column = audio_column
+        self.voice_prompts_column = voice_prompts_column
+        self.data = []
+        self._load()
+    
+    def _load(self):
+        with open(self.jsonl_path, 'r', encoding='utf-8') as f:
+            for line in f:
+                if line.strip():
+                    self.data.append(json.loads(line))
+    
+    def __len__(self):
+        return len(self.data)
+    
+    def __getitem__(self, idx):
+        return self.data[idx]
+
+
+def preprocess_dataset(args: PreprocessArguments) -> None:
+    """
+    داده‌ها را پردازش کنید و در فایل‌های PyTorch ذخیره کنید
+    """
+    logging.basicConfig(
+        format="%(asctime)s - %(levelname)s - %(message)s",
+        level=logging.INFO
+    )
+    
+    # بارگذاری پردازشگر
+    logger.info(f"Loading processor from {args.processor_name_or_path}")
+    processor = VibeVoiceProcessor.from_pretrained(args.processor_name_or_path)
+    
+    # بررسی semantic_tokenizer
+    has_semantic_tokenizer = hasattr(processor, "semantic_tokenizer") and processor.semantic_tokenizer is not None
+    logger.info(f"Semantic tokenizer available: {has_semantic_tokenizer}")
+    
+    if not has_semantic_tokenizer:
+        logger.warning("Semantic tokenizer not found in processor!")
+        logger.warning("This is OK for preprocessing - will use zero features as placeholders")
+    
+    # بارگذاری داده‌های خام
+    logger.info(f"Loading dataset from {args.train_jsonl}")
+    dataset = RawDatasetLoader(
+        args.train_jsonl,
+        text_column=args.text_column_name,
+        audio_column=args.audio_column_name,
+        voice_prompts_column=args.voice_prompts_column_name
+    )
+    logger.info(f"Dataset size: {len(dataset)}")
+    
+    # آماده‌سازی دایرکتوری خروجی
+    output_dir = Path(args.output_dir)
+    output_dir.mkdir(parents=True, exist_ok=True)
+    
+    preprocessed_data_dir = output_dir / "preprocessed"
+    preprocessed_data_dir.mkdir(parents=True, exist_ok=True)
+    
+    # دستور‌العمل collator
+    collator = VibeVoiceCollator(
+        processor=processor,
+        max_length=args.max_length,
+        speech_compress_ratio=getattr(processor, "speech_tok_compress_ratio", 3200),
+        semantic_vae_dim=128,  # پیش‌فرض
+        compute_semantics=has_semantic_tokenizer,  # فقط اگر موجود باشد
+        voice_prompt_drop_rate=0.0  # بدون حذف اثناء پردازش
+    )
+    
+    # پردازش در دسته‌های batch
+    all_samples = []
+    batch = []
+    device = torch.device(args.device)
+    
+    logger.info(f"Processing on device: {device}")
+    logger.info(f"Computing semantics: {has_semantic_tokenizer}")
+    logger.info(f"Max length: {args.max_length}")
+    
+    for idx in tqdm(range(len(dataset)), desc="Loading samples"):
+        item = dataset[idx]
+        batch.append(item)
+        
+        if len(batch) == args.per_device_batch_size or idx == len(dataset) - 1:
+            if len(batch) == 0:
+                continue
+            try:
+                # پردازش دسته
+                processed = collator(batch)
+                
+                # منتقل کردن به CPU برای ذخیره
+                processed_cpu = {}
+                for k, v in processed.items():
+                    if isinstance(v, torch.Tensor):
+                        processed_cpu[k] = v.cpu()
+                    else:
+                        processed_cpu[k] = v
+                
+                all_samples.append(processed_cpu)
+                batch = []
+                
+            except Exception as e:
+                logger.error(f"Error processing batch starting at index {idx - len(batch) + 1}: {e}")
+                import traceback
+                logger.error(traceback.format_exc())
+                batch = []
+                continue
+    
+    # ذخیره داده‌های پردازش‌شده
+    logger.info(f"Saving {len(all_samples)} batches...")
+    
+    # ذخیره به صورت یک فایل واحد یا چندین فایل
+    output_file = preprocessed_data_dir / "preprocessed_batches.pt"
+    torch.save(all_samples, output_file)
+    logger.info(f"Saved preprocessed data to {output_file}")
+    
+    # ذخیره metadata
+    metadata = {
+        "num_batches": len(all_samples),
+        "per_device_batch_size": args.per_device_batch_size,
+        "max_length": args.max_length,
+        "text_column": args.text_column_name,
+        "audio_column": args.audio_column_name,
+        "voice_prompts_column": args.voice_prompts_column_name,
+    }
+    
+    metadata_file = output_dir / "metadata.json"
+    with open(metadata_file, 'w') as f:
+        json.dump(metadata, f, indent=2)
+    logger.info(f"Saved metadata to {metadata_file}")
+    
+    logger.info("Preprocessing complete!")
+
+
+if __name__ == "__main__":
+    parser = HfArgumentParser(PreprocessArguments)
+    args = parser.parse_args_into_dataclasses()[0]
+    preprocess_dataset(args)

VibeVoice-tpu/src/preprocess_vibevoice_tpu.py

@@ -0,0 +1,697 @@
+"""
+VibeVoice Dataset Preprocessing on TPU v5e
+============================================
+
+این اسکریپت تمام داده‌ها را روی TPU پردازش کرده و نتایج را در فایل‌های .pt ذخیره می‌کند.
+از قدرت TPU برای اجرای مدل‌های Acoustic Tokenizer و Semantic Tokenizer استفاده می‌کند.
+
+مزیت نسبت به preprocess_vibevoice.py (CPU/GPU):
+  - اجرای tokenizer‌های عصبی روی TPU (200+ TFLOPS bf16)
+  - تبدیل dtype به bfloat16 هنگام پردازش (بهینه برای TPU v5e)
+  - پردازش موازی تنسورها روی TPU
+  - بدون نیاز به GPU — فقط TPU لازم است
+
+استفاده:
+    python preprocess_vibevoice_tpu.py \\
+        --model_name_or_path /path/to/surgery_model \\
+        --train_jsonl /path/to/data.jsonl \\
+        --output_dir /path/to/preprocessed_output \\
+        --preprocess_batch_size 8 \\
+        --max_length 800 \\
+        --num_workers 0
+
+خروجی:
+    output_dir/
+        preprocessed_batches_0000.pt
+        preprocessed_batches_0001.pt
+        ...
+        metadata.json
+"""
+
+import os
+import gc
+import sys
+import json
+import math
+import time
+import logging
+import functools
+from pathlib import Path
+from dataclasses import dataclass, field
+from typing import Optional, Dict, Any, List, Tuple
+
+# ============================================================================
+# TPU Environment Setup (must be before torch import)
+# ============================================================================
+from tpu_config import setup_tpu_env, TPU_CONFIG
+setup_tpu_env()
+
+import numpy as np
+import torch
+import torch.nn as nn
+
+# PyTorch/XLA imports
+import torch_xla
+import torch_xla.core.xla_model as xm
+import torch_xla.distributed.xla_multiprocessing as xmp
+
+# VibeVoice imports
+from vibevoice.modular.modeling_vibevoice import (
+    VibeVoiceForConditionalGeneration,
+)
+from vibevoice.processor.vibevoice_processor import VibeVoiceProcessor
+from data_vibevoice import _load_audio_to_24k, VibeVoiceCollator
+
+logger = logging.getLogger(__name__)
+
+
+# ============================================================================
+# SECTION 1: Arguments
+# ============================================================================
+
+@dataclass
+class TPUPreprocessArgs:
+    """Arguments for TPU preprocessing."""
+    # Model (needed for acoustic/semantic tokenizers)
+    model_name_or_path: str = field(
+        metadata={"help": "Path to surgery model (used for tokenizers)"}
+    )
+    processor_name_or_path: Optional[str] = field(
+        default=None,
+        metadata={"help": "Path to processor. Defaults to model_name_or_path."},
+    )
+
+    # Data input
+    train_jsonl: str = field(
+        metadata={"help": "Path to JSONL training data file"}
+    )
+
+    # Output
+    output_dir: str = field(
+        default="./preprocessed_tpu",
+        metadata={"help": "Directory to save preprocessed .pt files"},
+    )
+
+    # Preprocessing options
+    preprocess_batch_size: int = field(
+        default=8,
+        metadata={"help": "Number of samples per preprocessing batch"},
+    )
+    max_length: Optional[int] = field(
+        default=None,
+        metadata={"help": "Max sequence length. None = no limit."},
+    )
+    text_column_name: str = field(default="text")
+    audio_column_name: str = field(default="audio")
+    voice_prompts_column_name: str = field(default="voice_prompts")
+    speech_compress_ratio: int = field(default=3200)
+    semantic_vae_dim: int = field(default=128)
+    voice_prompt_drop_rate: float = field(default=0.0)
+
+    # Performance
+    save_every_n_batches: int = field(
+        default=100,
+        metadata={"help": "Save chunks every N batches to manage memory"},
+    )
+
+
+# ============================================================================
+# SECTION 2: Raw Data Loader
+# ============================================================================
+
+class RawDatasetLoader:
+    """Simple loader for JSONL datasets."""
+    def __init__(self, jsonl_path: str, text_column: str = "text",
+                 audio_column: str = "audio", voice_prompts_column: str = "voice_prompts"):
+        self.jsonl_path = jsonl_path
+        self.text_column = text_column
+        self.audio_column = audio_column
+        self.voice_prompts_column = voice_prompts_column
+        self.data = []
+        self._load()
+
+    def _load(self):
+        with open(self.jsonl_path, 'r', encoding='utf-8') as f:
+            for line in f:
+                if line.strip():
+                    self.data.append(json.loads(line))
+
+    def __len__(self):
+        return len(self.data)
+
+    def __getitem__(self, idx):
+        return self.data[idx]
+
+
+# ============================================================================
+# SECTION 3: TPU Model & Tokenizer Loading
+# ============================================================================
+
+def _patch_acoustic_encode_for_legacy_indexing(model_obj, logger_):
+    """Patch acoustic tokenizer encode to return [[...]] for legacy indexing."""
+    try:
+        acoustic = getattr(getattr(model_obj, "model", model_obj), "acoustic_tokenizer", None)
+        if acoustic is None or not hasattr(acoustic, "encode"):
+            logger_.warning("No acoustic_tokenizer.encode() found to patch.")
+            return
+        base_encode = acoustic.encode
+
+        def encode_wrapped(*args, **kwargs):
+            out = base_encode(*args, **kwargs)
+            try:
+                _ = out[0][0]
+                return out
+            except Exception:
+                pass
+            if isinstance(out, dict):
+                for k in ("frames", "codes", "tokens", "latents", "hidden_states"):
+                    if k in out:
+                        return [[out[k]]]
+                if len(out) > 0:
+                    return [[next(iter(out.values()))]]
+            for attr in ("frames", "codes", "tokens", "latents", "hidden_states"):
+                if hasattr(out, attr):
+                    return [[getattr(out, attr)]]
+            try:
+                if isinstance(out, torch.Tensor):
+                    return [[out]]
+            except Exception:
+                pass
+            return [[out]]
+
+        acoustic.encode = encode_wrapped
+        logger_.info("Patched acoustic_tokenizer.encode() for legacy indexing.")
+    except Exception as e:
+        logger_.warning(f"Failed to patch acoustic_tokenizer.encode(): {e}")
+
+
+def load_model_on_tpu(model_path: str, device: torch.device, dtype=torch.bfloat16):
+    """
+    Load model on TPU — only used for accessing tokenizers.
+    The LLM and other components are frozen/not used for preprocessing.
+    """
+    xm.master_print(f"  Loading model from {model_path}...")
+
+    # Try surgery model first
+    try:
+        from vibevoice_surgery_colab import _patch_vibevoice_config_for_qwen3, load_surgery_model
+        _patch_vibevoice_config_for_qwen3()
+        model = load_surgery_model(model_path, dtype=dtype, device_map="cpu")
+        xm.master_print("  Loaded as surgery model")
+    except (ImportError, Exception):
+        model = VibeVoiceForConditionalGeneration.from_pretrained(
+            model_path, torch_dtype=dtype, device_map="cpu"
+        )
+        xm.master_print("  Loaded as standard VibeVoice model")
+
+    _patch_acoustic_encode_for_legacy_indexing(model, logger)
+
+    # Move to TPU
+    xm.master_print(f"  Moving model to TPU device: {device}")
+    model = model.to(device)
+    xm.master_print("  Model loaded on TPU!")
+
+    return model
+
+
+# ============================================================================
+# SECTION 4: TPU-Accelerated Preprocessing Engine
+# ============================================================================
+
+class TPUPreprocessor:
+    """
+    Preprocesses raw VibeVoice data using TPU for compute-intensive operations.
+
+    Pipeline:
+      1. CPU: Load JSONL → read audio files → resample to 24kHz
+      2. CPU: Text tokenization via processor
+      3. TPU: Acoustic tokenizer encoding (neural network on TPU)
+      4. TPU: Semantic tokenizer encoding (neural network on TPU)
+      5. TPU: Tensor padding, stacking, dtype conversion to bfloat16
+      6. CPU: Save as .pt files
+    """
+
+    def __init__(
+        self,
+        model: VibeVoiceForConditionalGeneration,
+        processor: VibeVoiceProcessor,
+        device: torch.device,
+        args: TPUPreprocessArgs,
+    ):
+        self.model = model
+        self.processor = processor
+        self.device = device
+        self.args = args
+
+        # Verify tokenizers
+        self.acoustic_tokenizer = getattr(model.model, "acoustic_tokenizer", None)
+        self.semantic_tokenizer = getattr(model.model, "semantic_tokenizer", None)
+
+        # Also check processor for semantic tokenizer
+        proc_sem = getattr(processor, "semantic_tokenizer", None)
+        if self.semantic_tokenizer is None and proc_sem is not None:
+            self.semantic_tokenizer = proc_sem
+
+        xm.master_print(f"  Acoustic tokenizer: {'✓' if self.acoustic_tokenizer is not None else '✗'}")
+        xm.master_print(f"  Semantic tokenizer: {'✓' if self.semantic_tokenizer is not None else '✗'}")
+
+        # Build collator for text/audio processing
+        self.collator = VibeVoiceCollator(
+            processor=processor,
+            max_length=args.max_length,
+            speech_compress_ratio=args.speech_compress_ratio,
+            semantic_vae_dim=args.semantic_vae_dim,
+            compute_semantics=True,
+            voice_prompt_drop_rate=args.voice_prompt_drop_rate,
+        )
+
+    def preprocess_all(self) -> int:
+        """
+        Preprocess all data from JSONL and save as .pt files.
+
+        Returns:
+            Total number of batch files saved.
+        """
+        args = self.args
+
+        # ── Load raw data ──
+        xm.master_print(f"\n{'='*70}")
+        xm.master_print(f"  TPU v5e DATA PREPROCESSING")
+        xm.master_print(f"{'='*70}")
+        xm.master_print(f"  Input:  {args.train_jsonl}")
+        xm.master_print(f"  Output: {args.output_dir}")
+
+        raw_dataset = RawDatasetLoader(
+            args.train_jsonl,
+            text_column=args.text_column_name,
+            audio_column=args.audio_column_name,
+            voice_prompts_column=args.voice_prompts_column_name,
+        )
+        total_samples = len(raw_dataset)
+        xm.master_print(f"  Total samples: {total_samples}")
+
+        # ── Prepare output directory ──
+        output_dir = Path(args.output_dir)
+        output_dir.mkdir(parents=True, exist_ok=True)
+
+        # ── Process in batches ──
+        batch_size = args.preprocess_batch_size
+        num_batches = math.ceil(total_samples / batch_size)
+        save_every = args.save_every_n_batches
+
+        xm.master_print(f"  Batch size: {batch_size}")
+        xm.master_print(f"  Total batches: {num_batches}")
+        xm.master_print(f"  Save every: {save_every} batches")
+        xm.master_print(f"{'='*70}\n")
+
+        t_start = time.time()
+        chunk_idx = 0
+        chunk_buffer: List[Dict[str, torch.Tensor]] = []
+        total_saved = 0
+        samples_processed = 0
+
+        # Set model to eval mode (no gradients needed for preprocessing)
+        self.model.eval()
+
+        for batch_idx in range(num_batches):
+            start_idx = batch_idx * batch_size
+            end_idx = min(start_idx + batch_size, total_samples)
+            raw_batch = [raw_dataset[i] for i in range(start_idx, end_idx)]
+
+            try:
+                processed = self._preprocess_single_batch(raw_batch)
+
+                if processed is not None:
+                    # Move to CPU for storage
+                    processed_cpu = {}
+                    for k, v in processed.items():
+                        if isinstance(v, torch.Tensor):
+                            processed_cpu[k] = v.detach().cpu()
+                        else:
+                            processed_cpu[k] = v
+
+                    chunk_buffer.append(processed_cpu)
+                    samples_processed += end_idx - start_idx
+
+                    # Periodic XLA mark_step
+                    xm.mark_step()
+
+            except Exception as e:
+                logger.error(f"Error in batch {batch_idx} (samples {start_idx}-{end_idx}): {e}")
+                import traceback
+                logger.error(traceback.format_exc())
+                xm.mark_step()  # Clear XLA state after error
+                continue
+
+            # Save chunk when buffer is full or at the end
+            if len(chunk_buffer) >= save_every or batch_idx == num_batches - 1:
+                if chunk_buffer:
+                    chunk_path = output_dir / f"preprocessed_batches_{chunk_idx:04d}.pt"
+                    torch.save(chunk_buffer, str(chunk_path))
+                    total_saved += len(chunk_buffer)
+                    xm.master_print(
+                        f"  [{batch_idx+1}/{num_batches}] Saved chunk {chunk_idx} "
+                        f"({len(chunk_buffer)} batches) → {chunk_path.name} | "
+                        f"Samples: {samples_processed}/{total_samples}"
+                    )
+                    chunk_buffer = []
+                    chunk_idx += 1
+                    gc.collect()
+
+            # Progress
+            if (batch_idx + 1) % max(1, num_batches // 10) == 0:
+                elapsed = time.time() - t_start
+                speed = samples_processed / max(elapsed, 0.001)
+                eta = (total_samples - samples_processed) / max(speed, 0.001)
+                xm.master_print(
+                    f"  Progress: {samples_processed}/{total_samples} samples | "
+                    f"{speed:.1f} samples/s | ETA: {eta:.0f}s"
+                )
+
+        # ── Save metadata ──
+        t_total = time.time() - t_start
+        metadata = {
+            "total_batches": total_saved,
+            "total_samples": total_samples,
+            "num_chunk_files": chunk_idx,
+            "preprocess_batch_size": batch_size,
+            "max_length": args.max_length,
+            "speech_compress_ratio": args.speech_compress_ratio,
+            "semantic_vae_dim": args.semantic_vae_dim,
+            "processing_time_seconds": t_total,
+            "device": "tpu_v5e",
+            "dtype": "bfloat16",
+        }
+        metadata_path = output_dir / "metadata.json"
+        with open(metadata_path, 'w') as f:
+            json.dump(metadata, f, indent=2)
+
+        xm.master_print(f"\n{'='*70}")
+        xm.master_print(f"  PREPROCESSING COMPLETE!")
+        xm.master_print(f"  Total batches saved: {total_saved}")
+        xm.master_print(f"  Chunk files: {chunk_idx}")
+        xm.master_print(f"  Total time: {t_total:.1f}s")
+        if t_total > 0:
+            xm.master_print(f"  Average speed: {total_samples/t_total:.1f} samples/s")
+        xm.master_print(f"  Output directory: {args.output_dir}")
+        xm.master_print(f"{'='*70}\n")
+
+        return chunk_idx
+
+    @torch.no_grad()
+    def _preprocess_single_batch(self, raw_batch: List[Dict[str, Any]]) -> Optional[Dict[str, torch.Tensor]]:
+        """
+        Process a single batch of raw data.
+
+        Steps:
+          1. CPU: Collator does text tokenization + audio loading + padding
+          2. TPU: Move tensors to TPU, convert to bfloat16
+          3. TPU: Re-encode semantics on TPU if needed
+        """
+        args = self.args
+
+        # ── Step 1: CPU preprocessing via collator ──
+        # VibeVoiceCollator handles:
+        #   - Text tokenization via processor
+        #   - Audio loading & resampling to 24kHz
+        #   - Voice prompt processing
+        #   - Building input_ids, attention_mask, masks
+        #   - Acoustic/semantic feature extraction
+        processed = self.collator(raw_batch)
+
+        if not processed:
+            return None
+
+        # ── Step 2: Move all tensors to TPU and convert to bfloat16 ──
+        result = {}
+        for k, v in processed.items():
+            if isinstance(v, torch.Tensor):
+                v_tpu = v.to(self.device)
+                # Convert float tensors to bfloat16 for TPU v5e
+                if v_tpu.is_floating_point():
+                    v_tpu = v_tpu.to(dtype=torch.bfloat16)
+                result[k] = v_tpu
+            else:
+                result[k] = v
+
+        # ── Step 3: Re-encode semantic features on TPU if placeholder ──
+        if ("speech_semantic_tensors" in result
+            and "speech_tensors" in result
+            and result["speech_semantic_tensors"] is not None):
+
+            sem = result["speech_semantic_tensors"]
+            if torch.all(sem == 0) and self.semantic_tokenizer is not None:
+                try:
+                    result["speech_semantic_tensors"] = self._encode_semantics_on_tpu(
+                        result["speech_tensors"],
+                        result.get("speech_masks"),
+                    )
+                except Exception as e:
+                    logger.debug(f"TPU semantic encoding failed, keeping zeros: {e}")
+
+        # ── Step 4: Re-encode acoustic features on TPU if needed ──
+        # Acoustic features are encoded via forward_speech_features in the collator
+        # but the collator uses CPU. If acoustic_tokenizer is on TPU, we can
+        # benefit from TPU speed for the acoustic encoding too.
+        if (self.acoustic_tokenizer is not None
+            and "speech_tensors" in result
+            and result["speech_tensors"] is not None):
+
+            # The speech_tensors are raw waveforms — acoustic encoding is done
+            # during training via model.forward_speech_features(). For preprocessing,
+            # we ensure the raw waveforms are properly formatted on TPU.
+            pass  # Acoustic encoding happens during forward pass, waveforms are stored as-is
+
+        # ── Step 5: Convert non-float tensors back to CPU-compatible types ──
+        # Ensure integer/bool tensors stay as their original types
+        for k in result:
+            if isinstance(result[k], torch.Tensor):
+                if result[k].dtype == torch.bfloat16:
+                    pass  # Keep bfloat16 — finetune script will handle dtype
+                elif result[k].dtype in (torch.int64, torch.int32, torch.int16):
+                    pass  # Keep integer types
+                elif result[k].dtype == torch.bool:
+                    pass  # Keep bool
+
+        return result
+
+    def _encode_semantics_on_tpu(
+        self,
+        speech_tensors: torch.Tensor,
+        speech_masks: Optional[torch.Tensor],
+    ) -> torch.Tensor:
+        """
+        Encode semantic features using the semantic tokenizer on TPU.
+
+        This is the main TPU-accelerated operation — semantic encoding is a
+        neural network forward pass that benefits greatly from TPU compute.
+        """
+        device = speech_tensors.device
+        batch_size = speech_tensors.shape[0]
+        max_latent_len = speech_masks.shape[1] if speech_masks is not None else 1
+        sem_dim = self.args.semantic_vae_dim
+
+        semantic_features = []
+
+        for i in range(batch_size):
+            wav = speech_tensors[i]
+
+            # Determine actual latent length from mask
+            if speech_masks is not None:
+                mask = speech_masks[i]
+                if mask.dim() >= 1 and mask.any():
+                    latent_len = min(int(mask.sum().item()), max_latent_len)
+                else:
+                    latent_len = max_latent_len
+            else:
+                latent_len = max_latent_len
+
+            try:
+                sem_out = self.semantic_tokenizer.encode(
+                    wav.unsqueeze(0) if wav.dim() == 1 else wav
+                )
+
+                # Handle various output formats
+                if isinstance(sem_out, torch.Tensor):
+                    sem_feat = sem_out.float()
+                elif isinstance(sem_out, dict):
+                    for key in ('features', 'mean', 'hidden_states', 'tokens'):
+                        if key in sem_out:
+                            sem_feat = sem_out[key].float()
+                            break
+                    else:
+                        sem_feat = torch.zeros(latent_len, sem_dim, device=device)
+                elif hasattr(sem_out, 'mean'):
+                    sem_feat = sem_out.mean.float()
+                else:
+                    sem_feat = torch.zeros(latent_len, sem_dim, device=device)
+
+                # Ensure shape [T, D]
+                if sem_feat.dim() == 3:
+                    sem_feat = sem_feat.squeeze(0)
+                if sem_feat.dim() == 1:
+                    sem_feat = sem_feat.unsqueeze(0)
+
+                # Pad/trim to match latent_len
+                T = sem_feat.shape[0]
+                if T < latent_len:
+                    pad = torch.zeros(
+                        latent_len - T, sem_feat.shape[1],
+                        device=device, dtype=sem_feat.dtype
+                    )
+                    sem_feat = torch.cat([sem_feat, pad], dim=0)
+                elif T > latent_len:
+                    sem_feat = sem_feat[:latent_len]
+
+                # Ensure correct feature dimension
+                if sem_feat.shape[1] != sem_dim:
+                    if sem_feat.shape[1] < sem_dim:
+                        pad_d = torch.zeros(
+                            sem_feat.shape[0], sem_dim - sem_feat.shape[1],
+                            device=device, dtype=sem_feat.dtype
+                        )
+                        sem_feat = torch.cat([sem_feat, pad_d], dim=1)
+                    else:
+                        sem_feat = sem_feat[:, :sem_dim]
+
+                semantic_features.append(sem_feat.to(dtype=torch.bfloat16))
+
+            except Exception as e:
+                logger.debug(f"Semantic encode failed for sample {i}: {e}")
+                semantic_features.append(
+                    torch.zeros(latent_len, sem_dim, device=device, dtype=torch.bfloat16)
+                )
+
+        # Stack [B, T, D]
+        if semantic_features:
+            return torch.stack(semantic_features, dim=0)
+        else:
+            return torch.zeros(
+                batch_size, max_latent_len, sem_dim,
+                device=device, dtype=torch.bfloat16
+            )
+
+
+# ============================================================================
+# SECTION 5: Single-process TPU preprocessing (for Colab / single host)
+# ============================================================================
+
+def preprocess_single_process(rank: int, args: TPUPreprocessArgs):
+    """
+    Run preprocessing on a single TPU chip.
+    Uses only rank 0 to avoid data duplication.
+    """
+    device = xm.xla_device()
+
+    if not xm.is_master_ordinal():
+        return  # Only master process does preprocessing
+
+    xm.master_print(f"\n{'='*70}")
+    xm.master_print(f"  TPU v5e Data Preprocessing | Device: {device}")
+    xm.master_print(f"{'='*70}")
+
+    # ── Load Processor ──
+    processor_path = args.processor_name_or_path or args.model_name_or_path
+    xm.master_print(f"  Loading processor from {processor_path}")
+    processor = VibeVoiceProcessor.from_pretrained(processor_path)
+
+    # ── Load Model on TPU ──
+    model = load_model_on_tpu(args.model_name_or_path, device)
+
+    # ── Set processor's semantic tokenizer from model ──
+    proc_sem = getattr(model.model, "semantic_tokenizer", None)
+    if proc_sem is not None:
+        processor.semantic_tokenizer = proc_sem
+
+    # ── Run Preprocessing ──
+    preprocessor = TPUPreprocessor(model, processor, device, args)
+    num_files = preprocessor.preprocess_all()
+
+    xm.master_print(f"  Done! {num_files} chunk files saved to {args.output_dir}")
+
+
+# ============================================================================
+# SECTION 6: Entry Point
+# ============================================================================
+
+def main():
+    import argparse
+
+    parser = argparse.ArgumentParser(
+        description="VibeVoice TPU Data Preprocessing — preprocess on TPU, save as .pt",
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+    )
+
+    # Model
+    parser.add_argument("--model_name_or_path", type=str, required=True,
+                        help="Path to surgery/VibeVoice model (for tokenizers)")
+    parser.add_argument("--processor_name_or_path", type=str, default=None,
+                        help="Path to processor directory")
+
+    # Data
+    parser.add_argument("--train_jsonl", type=str, required=True,
+                        help="Path to JSONL training data")
+    parser.add_argument("--output_dir", type=str, default="./preprocessed_tpu",
+                        help="Output directory for .pt files")
+
+    # Preprocessing
+    parser.add_argument("--preprocess_batch_size", type=int, default=8,
+                        help="Samples per preprocessing batch")
+    parser.add_argument("--max_length", type=int, default=None,
+                        help="Max sequence length")
+    parser.add_argument("--text_column_name", type=str, default="text")
+    parser.add_argument("--audio_column_name", type=str, default="audio")
+    parser.add_argument("--voice_prompts_column_name", type=str, default="voice_prompts")
+    parser.add_argument("--speech_compress_ratio", type=int, default=3200)
+    parser.add_argument("--semantic_vae_dim", type=int, default=128)
+    parser.add_argument("--voice_prompt_drop_rate", type=float, default=0.0)
+
+    # Performance
+    parser.add_argument("--save_every_n_batches", type=int, default=100,
+                        help="Save .pt chunk files every N batches")
+
+    args = parser.parse_args()
+
+    # Build args dataclass
+    preprocess_args = TPUPreprocessArgs(
+        model_name_or_path=args.model_name_or_path,
+        processor_name_or_path=args.processor_name_or_path,
+        train_jsonl=args.train_jsonl,
+        output_dir=args.output_dir,
+        preprocess_batch_size=args.preprocess_batch_size,
+        max_length=args.max_length,
+        text_column_name=args.text_column_name,
+        audio_column_name=args.audio_column_name,
+        voice_prompts_column_name=args.voice_prompts_column_name,
+        speech_compress_ratio=args.speech_compress_ratio,
+        semantic_vae_dim=args.semantic_vae_dim,
+        voice_prompt_drop_rate=args.voice_prompt_drop_rate,
+        save_every_n_batches=args.save_every_n_batches,
+    )
+
+    # ── Print config ──
+    print(f"\n{'='*70}")
+    print(f"  VibeVoice TPU Data Preprocessing")
+    print(f"{'='*70}")
+    print(f"  Model:     {args.model_name_or_path}")
+    print(f"  JSONL:     {args.train_jsonl}")
+    print(f"  Output:    {args.output_dir}")
+    print(f"  Batch:     {args.preprocess_batch_size}")
+    print(f"  Max len:   {args.max_length}")
+    print(f"  Sem dim:   {args.semantic_vae_dim}")
+    print(f"  Save every: {args.save_every_n_batches} batches")
+    print(f"{'='*70}\n")
+
+    # ── Launch on TPU ──
+    # Use only 1 process (rank 0) since preprocessing is sequential
+    # but benefits from TPU compute power for tokenizers
+    xmp.spawn(
+        preprocess_single_process,
+        args=(preprocess_args,),
+        nprocs=1,  # Single TPU chip for preprocessing
+        start_method="fork",
+    )
+
+
+if __name__ == "__main__":
+    main()

VibeVoice-tpu/src/tpu_config.py

@@ -0,0 +1,275 @@
+"""
+TPU v5e-8 Configuration for VibeVoice Fine-Tuning
+===================================================
+
+TPU v5e specifications:
+  - 8 chips per host (1 TPU v5e-8 pod slice)
+  - 16 GB HBM per chip = 128 GB total HBM
+  - bfloat16 native support (preferred over fp16)
+  - 200+ TFLOPS bf16 per chip
+
+Key differences from GPU training:
+  - Use PyTorch/XLA instead of CUDA
+  - bfloat16 instead of fp16
+  - XLA graph compilation (static graphs)
+  - xm.mark_step() for explicit synchronization
+  - MpDeviceLoader for distributed data loading
+"""
+
+import os
+
+
+# ============================================================================
+# TPU Environment Setup
+# ============================================================================
+
+def setup_tpu_env():
+    """Configure environment variables for optimal TPU v5e performance."""
+    # XLA configuration
+    os.environ.setdefault("XLA_USE_BF16", "1")
+    os.environ.setdefault("XLA_DOWNCAST_BF16", "1")
+
+    # PJRT runtime (modern TPU runtime)
+    os.environ.setdefault("PJRT_DEVICE", "TPU")
+
+    # Performance tuning
+    os.environ.setdefault("XLA_SYNC_WAIT", "1")
+    os.environ.setdefault("XLA_PERSISTENT_CACHE_PATH", "/tmp/xla_cache")
+
+    # Disable unnecessary features
+    os.environ.setdefault("TOKENIZERS_PARALLELISM", "false")
+
+    # XLA compilation flags for performance
+    os.environ.setdefault("XLA_FLAGS",
+        "--xla_gpu_cuda_data_dir=/dev/null "  # Not needed for TPU
+        "--xla_force_host_platform_device_count=8"  # 8 TPU chips
+    )
+
+
+# ============================================================================
+# TPU Device Configuration
+# ============================================================================
+
+TPU_CONFIG = {
+    # Number of TPU chips (v5e-8 = 8 chips)
+    "num_chips": 8,
+
+    # HBM per chip
+    "hbm_per_chip_gb": 16,
+
+    # Total available HBM
+    "total_hbm_gb": 128,
+
+    # Data parallelism (use all 8 chips for data parallel)
+    "data_parallel_size": 8,
+
+    # Model parallelism (1 = no model parallelism)
+    "model_parallel_size": 1,
+
+    # Preferred dtype for TPU v5e
+    "dtype": "bfloat16",
+}
+
+
+# ============================================================================
+# Training Configuration for TPU v5e-8
+# ============================================================================
+
+TPU_TRAINING_CONFIG = {
+    # ---- Batch Size & Accumulation ----
+    # Per-chip batch size (limited by 16GB HBM per chip)
+    # For VibeVoice-7B surgery model: batch_size=1 is safe with gradient checkpointing
+    "per_device_train_batch_size": 1,
+
+    # Gradient accumulation steps (effective batch = 1 * 8 * 8 = 64)
+    "gradient_accumulation_steps": 8,
+
+    # Total effective batch size
+    # = per_device_batch * num_chips * grad_accum = 1 * 8 * 8 = 64
+    "effective_batch_size": 64,
+
+    # ---- Learning Rate ----
+    "learning_rate": 2e-5,
+    "lr_scheduler_type": "cosine",
+    "warmup_ratio": 0.1,
+    "warmup_steps": 100,
+
+    # ---- Precision ----
+    # bfloat16 is native on TPU v5e (NOT fp16)
+    "bf16": True,
+    "fp16": False,
+
+    # ---- Memory Optimization ----
+    "gradient_checkpointing": True,
+    "ddpm_batch_mul": 1,
+
+    # ---- Loss Weights ----
+    "ce_loss_weight": 1.0,
+    "diffusion_loss_weight": 1.0,
+
+    # ---- Gradient Clipping ----
+    "max_grad_norm": 1.0,
+
+    # ---- Training Duration ----
+    "max_steps": 5000,
+    "num_train_epochs": 3,
+    "max_epochs": 3,
+
+    # ---- Logging & Saving ----
+    "logging_steps": 10,
+    "eval_steps": 500,
+    "save_steps": 500,
+    "save_total_limit": 3,
+
+    # ---- Data Loading ----
+    "dataloader_num_workers": 4,
+    "prefetch_factor": 4,
+
+    # ---- Evaluation ----
+    "eval_split_size": 0.05,
+    "do_eval": True,
+
+    # ---- Random Seed ----
+    "seed": 42,
+}
+
+
+# ============================================================================
+# LoRA Configuration for TPU
+# ============================================================================
+
+TPU_LORA_CONFIG = {
+    "lora_r": 8,
+    "lora_alpha": 32,
+    "lora_dropout": 0.05,
+    "lora_target_modules": "q_proj,k_proj,v_proj,o_proj,gate_proj,up_proj,down_proj",
+}
+
+
+# ============================================================================
+# Component Freezing Configuration
+# ============================================================================
+
+FREEZE_CONFIG = {
+    "freeze_llm": False,  # LoRA wraps LLM, so it's partially trainable
+    "freeze_diffusion_head": True,
+    "freeze_surgery_module": False,  # Train surgery module
+    "freeze_connectors": False,      # Train connectors
+    "freeze_acoustic_tokenizer": True,
+    "freeze_semantic_tokenizer": True,
+    "freeze_lm_head": True,
+
+    # Fine-tune flags
+    "train_diffusion_head": False,
+    "train_connectors": True,
+    "train_surgery_module": True,
+
+    # Optional: wrap diffusion head with LoRA
+    "lora_wrap_diffusion_head": False,
+}
+
+
+# ============================================================================
+# XLA Compilation & Performance Settings
+# ============================================================================
+
+XLA_CONFIG = {
+    # Number of batches to prefetch (larger = better throughput, more memory)
+    "prefetch_factor": 4,
+
+    # Enable XLA compilation caching (faster restarts)
+    "enable_compilation_cache": True,
+
+    # Mark step frequency (sync XLA graph every N batches)
+    # Should match gradient_accumulation_steps
+    "mark_step_frequency": 1,
+
+    # XLA auto-jit compilation
+    "auto_jit": True,
+}
+
+
+# ============================================================================
+# Checkpoint Configuration
+# ============================================================================
+
+CHECKPOINT_CONFIG = {
+    # Save format compatible with GPU inference
+    "save_format": "pytorch",
+
+    # Components to save
+    "save_lora_adapters": True,
+    "save_diffusion_head": True,
+    "save_connectors": True,
+    "save_surgery_module": True,
+
+    # Checkpoint directory structure
+    # output_dir/
+    #   checkpoint-{step}/
+    #     lora/                      # LLM LoRA adapters
+    #     lora/diffusion_head/       # Diffusion head LoRA or full weights
+    #     lora/diffusion_head_full.bin
+    #     lora/acoustic_connector/
+    #     lora/semantic_connector/
+    #     lora/surgery_module/
+    #     training_state.pt          # Optimizer/scheduler state
+}
+
+
+# ============================================================================
+# Memory Estimation
+# ============================================================================
+
+def estimate_memory_usage():
+    """
+    Rough memory estimation for TPU v5e-8.
+    
+    Model components (approximate, bf16):
+      - LLM (Qwen3-4B): ~8 GB
+      - Diffusion Head: ~2 GB
+      - Acoustic Tokenizer: ~0.5 GB
+      - Semantic Tokenizer: ~0.5 GB
+      - Connectors: ~0.02 GB
+      - Surgery Module: ~0.04 GB
+      - LM Head: ~0.3 GB
+    Total model: ~12 GB per chip (fits in 16 GB HBM)
+    
+    Training overhead:
+      - Gradients (trainable params): ~0.5 GB
+      - Optimizer states (AdamW): ~1 GB
+      - Activations (with gradient checkpointing): ~2 GB
+    Total overhead: ~3.5 GB
+    
+    Total: ~15.5 GB per chip (tight but fits in 16 GB)
+    """
+    
+    estimates = {
+        "model_bf16_gb": 12.0,
+        "gradients_gb": 0.5,
+        "optimizer_gb": 1.0,
+        "activations_gb": 2.0,
+        "total_gb": 15.5,
+        "available_gb": 16.0,
+        "headroom_gb": 0.5,
+    }
+    
+    print("=" * 50)
+    print("  MEMORY ESTIMATION (per TPU chip, bf16)")
+    print("=" * 50)
+    for key, val in estimates.items():
+        print(f"  {key:<25s}: {val:>6.1f} GB")
+    print("=" * 50)
+    
+    if estimates["total_gb"] > estimates["available_gb"]:
+        print("  ⚠️  WARNING: Estimated usage exceeds available memory!")
+        print("  Consider: reduce batch size, increase grad accumulation,")
+        print("  or freeze more components.")
+    else:
+        print("  ✅ Model fits within TPU v5e HBM budget.")
+    
+    return estimates
+
+
+if __name__ == "__main__":
+    setup_tpu_env()
+    estimate_memory_usage()

VibeVoice-tpu/src/vibevoice/configs/qwen2.5_1.5b_64k.json

@@ -0,0 +1,112 @@
+{
+  "_attn_implementation_autoset": true,
+  "acoustic_vae_dim": 64,
+  "acoustic_tokenizer_config": {
+    "causal": true,
+    "channels": 1,
+    "conv_bias": true,
+    "conv_norm": "none",
+    "corpus_normalize": 0.0,
+    "decoder_depths": null,
+    "decoder_n_filters": 32,
+    "decoder_ratios": [
+      8,
+      5,
+      5,
+      4,
+      2,
+      2
+    ],
+    "disable_last_norm": true,
+    "encoder_depths": "3-3-3-3-3-3-8",
+    "encoder_n_filters": 32,
+    "encoder_ratios": [
+      8,
+      5,
+      5,
+      4,
+      2,
+      2
+    ],
+    "fix_std": 0.5,
+    "layer_scale_init_value": 1e-06,
+    "layernorm": "RMSNorm",
+    "layernorm_elementwise_affine": true,
+    "layernorm_eps": 1e-05,
+    "mixer_layer": "depthwise_conv",
+    "model_type": "vibepod_acoustic_tokenizer",
+    "pad_mode": "constant",
+    "std_dist_type": "gaussian",
+    "vae_dim": 64,
+    "weight_init_value": 0.01
+  },
+  "decoder_config": {
+    "attention_dropout": 0.0,
+    "hidden_act": "silu",
+    "hidden_size": 1536,
+    "initializer_range": 0.02,
+    "intermediate_size": 8960,
+    "max_position_embeddings": 65536,
+    "max_window_layers": 28,
+    "model_type": "qwen2",
+    "num_attention_heads": 12,
+    "num_hidden_layers": 28,
+    "num_key_value_heads": 2,
+    "rms_norm_eps": 1e-06,
+    "rope_scaling": null,
+    "rope_theta": 1000000.0,
+    "sliding_window": null,
+    "tie_word_embeddings": true,
+    "torch_dtype": "bfloat16",
+    "use_cache": true,
+    "use_sliding_window": false,
+    "vocab_size": 151936
+  },
+  "diffusion_head_config": {
+    "ddpm_batch_mul": 4,
+    "ddpm_beta_schedule": "cosine",
+    "ddpm_num_inference_steps": 20,
+    "ddpm_num_steps": 1000,
+    "diffusion_type": "ddpm",
+    "head_ffn_ratio": 3.0,
+    "head_layers": 4,
+    "hidden_size": 1536,
+    "latent_size": 64,
+    "model_type": "vibepod_diffusion_head",
+    "prediction_type": "v_prediction",
+    "rms_norm_eps": 1e-05,
+    "speech_vae_dim": 64
+  },
+  "model_type": "vibepod",
+  "semantic_tokenizer_config": {
+    "causal": true,
+    "channels": 1,
+    "conv_bias": true,
+    "conv_norm": "none",
+    "corpus_normalize": 0.0,
+    "disable_last_norm": true,
+    "encoder_depths": "3-3-3-3-3-3-8",
+    "encoder_n_filters": 32,
+    "encoder_ratios": [
+      8,
+      5,
+      5,
+      4,
+      2,
+      2
+    ],
+    "fix_std": 0,
+    "layer_scale_init_value": 1e-06,
+    "layernorm": "RMSNorm",
+    "layernorm_elementwise_affine": true,
+    "layernorm_eps": 1e-05,
+    "mixer_layer": "depthwise_conv",
+    "model_type": "vibepod_semantic_tokenizer",
+    "pad_mode": "constant",
+    "std_dist_type": "none",
+    "vae_dim": 128,
+    "weight_init_value": 0.01
+  },
+  "semantic_vae_dim": 128,
+  "torch_dtype": "bfloat16"
+}

VibeVoice-tpu/src/vibevoice/configs/qwen2.5_7b_32k.json

@@ -0,0 +1,113 @@
+{
+  "_attn_implementation_autoset": true,
+  "acoustic_vae_dim": 64,
+  "acoustic_tokenizer_config": {
+    "causal": true,
+    "channels": 1,
+    "conv_bias": true,
+    "conv_norm": "none",
+    "corpus_normalize": 0.0,
+    "decoder_depths": null,
+    "decoder_n_filters": 32,
+    "decoder_ratios": [
+      8,
+      5,
+      5,
+      4,
+      2,
+      2
+    ],
+    "disable_last_norm": true,
+    "encoder_depths": "3-3-3-3-3-3-8",
+    "encoder_n_filters": 32,
+    "encoder_ratios": [
+      8,
+      5,
+      5,
+      4,
+      2,
+      2
+    ],
+    "fix_std": 0.5,
+    "layer_scale_init_value": 1e-06,
+    "layernorm": "RMSNorm",
+    "layernorm_elementwise_affine": true,
+    "layernorm_eps": 1e-05,
+    "mixer_layer": "depthwise_conv",
+    "model_type": "vibepod_acoustic_tokenizer",
+    "pad_mode": "constant",
+    "std_dist_type": "gaussian",
+    "vae_dim": 64,
+    "weight_init_value": 0.01
+  },
+  "decoder_config": {
+    "attention_dropout": 0.0,
+    "hidden_act": "silu",
+    "hidden_size": 3584,
+    "initializer_range": 0.02,
+    "intermediate_size": 18944,
+    "max_position_embeddings": 32768,
+    "max_window_layers": 28,
+    "model_type": "qwen2",
+    "num_attention_heads": 28,
+    "num_hidden_layers": 28,
+    "num_key_value_heads": 4,
+    "rms_norm_eps": 1e-06,
+    "rope_theta": 1000000.0,
+    "sliding_window": null,
+    "tie_word_embeddings": false,
+    "torch_dtype": "bfloat16",
+    "transformers_version": "4.40.1",
+    "use_cache": true,
+    "use_mrope": false,
+    "use_sliding_window": false,
+    "vocab_size": 152064
+  },
+  "diffusion_head_config": {
+    "ddpm_batch_mul": 4,
+    "ddpm_beta_schedule": "cosine",
+    "ddpm_num_inference_steps": 20,
+    "ddpm_num_steps": 1000,
+    "diffusion_type": "ddpm",
+    "head_ffn_ratio": 3.0,
+    "head_layers": 4,
+    "hidden_size": 3584,
+    "latent_size": 64,
+    "model_type": "vibepod_diffusion_head",
+    "prediction_type": "v_prediction",
+    "rms_norm_eps": 1e-05,
+    "speech_vae_dim": 64
+  },
+  "model_type": "vibepod",
+  "semantic_tokenizer_config": {
+    "causal": true,
+    "channels": 1,
+    "conv_bias": true,
+    "conv_norm": "none",
+    "corpus_normalize": 0.0,
+    "disable_last_norm": true,
+    "encoder_depths": "3-3-3-3-3-3-8",
+    "encoder_n_filters": 32,
+    "encoder_ratios": [
+      8,
+      5,
+      5,
+      4,
+      2,
+      2
+    ],
+    "fix_std": 0,
+    "layer_scale_init_value": 1e-06,
+    "layernorm": "RMSNorm",
+    "layernorm_elementwise_affine": true,
+    "layernorm_eps": 1e-05,
+    "mixer_layer": "depthwise_conv",
+    "model_type": "vibepod_semantic_tokenizer",
+    "pad_mode": "constant",
+    "std_dist_type": "none",
+    "vae_dim": 128,
+    "weight_init_value": 0.01
+  },
+  "semantic_vae_dim": 128,
+  "torch_dtype": "bfloat16"
+}

VibeVoice-tpu/src/vibevoice/modular/configuration_vibevoice.py

@@ -0,0 +1,266 @@
+""" VibeVoice_AcousticTokenizer model configuration"""
+
+from typing import Dict, List, Optional, Tuple
+
+from transformers.configuration_utils import PretrainedConfig 
+from transformers.utils import logging
+
+from transformers.models.qwen2.configuration_qwen2 import Qwen2Config
+
+# Try to import Qwen3Config (available in transformers >= 4.51.0)
+try:
+    from transformers import Qwen3Config
+except ImportError:
+    Qwen3Config = None
+
+logger = logging.get_logger(__name__)
+
+
+class VibeVoiceAcousticTokenizerConfig(PretrainedConfig):
+    model_type = "vibevoice_acoustic_tokenizer"
+
+    def __init__(
+        self,
+        channels: int = 1,
+        corpus_normalize: float = 0.0,
+        causal: bool = True,
+        vae_dim: int = 64,
+        fix_std: float = 0.5,
+        std_dist_type: str = 'gaussian',
+        # common 
+        mixer_layer: str = 'depthwise_conv',
+        conv_norm: str = 'none',
+        pad_mode: str = 'constant',
+        disable_last_norm: bool = True,
+        layernorm: str = 'RMSNorm',
+        layernorm_eps: float = 1e-5,
+        layernorm_elementwise_affine: bool = True,
+        conv_bias: bool = True,
+        layer_scale_init_value: float = 1e-6,
+        weight_init_value: float = 1e-2,
+        # encoder specific
+        encoder_n_filters: int = 32,
+        encoder_ratios: Optional[List[int]] = [8,5,5,4,2,2],
+        encoder_depths: str = "3-3-3-3-3-3-8",
+        # decoder specific
+        decoder_n_filters: int = 32,
+        decoder_ratios: Optional[List[int]] = None, # if None, same as encoder
+        decoder_depths: Optional[str] = None,
+        **kwargs
+    ):
+        super().__init__(**kwargs)
+        self.channels = channels
+        self.corpus_normalize = corpus_normalize
+        self.causal = causal
+        self.vae_dim = vae_dim
+        self.fix_std = fix_std
+        self.std_dist_type = std_dist_type
+        
+        # common parameters
+        self.conv_norm = conv_norm
+        self.pad_mode = pad_mode
+        self.layernorm_eps = layernorm_eps
+        self.disable_last_norm = disable_last_norm
+        self.layernorm = layernorm
+        self.layernorm_elementwise_affine = layernorm_elementwise_affine
+        self.conv_bias = conv_bias
+        self.layer_scale_init_value = layer_scale_init_value
+        self.weight_init_value = weight_init_value
+        self.mixer_layer = mixer_layer
+
+        # encoder specific parameters
+        self.encoder_n_filters = encoder_n_filters
+        self.encoder_ratios = encoder_ratios
+        self.encoder_depths = encoder_depths
+        
+        # decoder specific parameters
+        self.decoder_ratios = decoder_ratios if decoder_ratios is not None else encoder_ratios
+        self.decoder_n_filters = decoder_n_filters
+        self.decoder_depths = decoder_depths
+
+
+class VibeVoiceSemanticTokenizerConfig(PretrainedConfig):
+    model_type = "vibevoice_semantic_tokenizer"
+    
+    def __init__(
+        self,
+        channels: int = 1,
+        corpus_normalize: float = 0.0,
+        causal: bool = True,
+        vae_dim: int = 64,
+        fix_std: float = 0,
+        std_dist_type: str = 'none',
+        # common 
+        mixer_layer: str = 'depthwise_conv',
+        conv_norm: str = 'none',
+        pad_mode: str = 'constant',
+        disable_last_norm: bool = True,
+        layernorm: str = 'RMSNorm',
+        layernorm_eps: float = 1e-5,
+        layernorm_elementwise_affine: bool = True,
+        conv_bias: bool = True,
+        layer_scale_init_value: float = 1e-6,
+        weight_init_value: float = 1e-2,
+        # encoder specific
+        encoder_n_filters: int = 32,
+        encoder_ratios: Optional[List[int]] = [8,5,5,4,2,2],
+        encoder_depths: str = "3-3-3-3-3-3-8",
+        **kwargs
+    ):
+        super().__init__(**kwargs)
+        self.channels = channels
+        self.corpus_normalize = corpus_normalize
+        self.causal = causal
+        self.vae_dim = vae_dim
+        self.fix_std = fix_std
+        self.std_dist_type = std_dist_type
+        
+        # common parameters
+        self.conv_norm = conv_norm
+        self.pad_mode = pad_mode
+        self.layernorm_eps = layernorm_eps
+        self.disable_last_norm = disable_last_norm
+        self.layernorm = layernorm
+        self.layernorm_elementwise_affine = layernorm_elementwise_affine
+        self.conv_bias = conv_bias
+        self.layer_scale_init_value = layer_scale_init_value
+        self.weight_init_value = weight_init_value
+        self.mixer_layer = mixer_layer
+
+        # encoder specific parameters
+        self.encoder_n_filters = encoder_n_filters
+        self.encoder_ratios = encoder_ratios
+        self.encoder_depths = encoder_depths
+        
+
+class VibeVoiceDiffusionHeadConfig(PretrainedConfig):
+    model_type = "vibevoice_diffusion_head"
+
+    def __init__(
+        self,
+        hidden_size=768,
+        head_layers=4,
+        head_ffn_ratio=3.0,
+        rms_norm_eps=1e-5,
+        latent_size=64,
+        speech_vae_dim=None,
+        prediction_type="v_prediction",
+        diffusion_type="ddpm",
+        ddpm_num_steps=1000,
+        ddpm_num_inference_steps=20,
+        ddpm_beta_schedule="cosine",
+        ddpm_batch_mul=4,
+        **kwargs
+    ):
+        self.hidden_size = hidden_size
+        self.head_layers = head_layers
+        self.head_ffn_ratio = head_ffn_ratio
+        self.rms_norm_eps = rms_norm_eps
+        self.latent_size = latent_size
+        self.speech_vae_dim = speech_vae_dim
+        self.prediction_type = prediction_type
+        self.diffusion_type = diffusion_type
+        self.ddpm_num_steps = ddpm_num_steps
+        self.ddpm_num_inference_steps = ddpm_num_inference_steps
+        self.ddpm_beta_schedule = ddpm_beta_schedule
+        self.ddpm_batch_mul = ddpm_batch_mul
+        
+        super().__init__(**kwargs)
+
+class VibeVoiceConfig(PretrainedConfig):
+    model_type = "vibevoice"
+    is_composition = True
+    sub_configs = {
+        "acoustic_tokenizer_config": VibeVoiceAcousticTokenizerConfig, 
+        "semantic_tokenizer_config": VibeVoiceSemanticTokenizerConfig,
+        "decoder_config": Qwen2Config,
+        "diffusion_head_config": VibeVoiceDiffusionHeadConfig,
+    }
+    # keys_to_ignore_at_inference = ["past_key_values"]
+    # Default tensor parallel plan for base model `Qwen2`
+    base_model_tp_plan = {
+        "layers.*.self_attn.q_proj": "colwise",
+        "layers.*.self_attn.k_proj": "colwise",
+        "layers.*.self_attn.v_proj": "colwise",
+        "layers.*.self_attn.o_proj": "rowwise",
+        "layers.*.mlp.gate_proj": "colwise",
+        "layers.*.mlp.up_proj": "colwise",
+        "layers.*.mlp.down_proj": "rowwise",
+    }
+    
+    def __init__(
+        self,
+        acoustic_tokenizer_config=None,
+        semantic_tokenizer_config=None,
+        decoder_config=None,
+        diffusion_head_config=None,
+        **kwargs
+    ):
+
+        # kwargs["_attn_implementation"] = "flash_attention_2"
+        kwargs["_attn_implementation_autoset"] = False 
+
+        if acoustic_tokenizer_config is None:
+            self.acoustic_tokenizer_config = self.sub_configs["acoustic_tokenizer_config"]()
+        elif isinstance(acoustic_tokenizer_config, dict):
+            acoustic_tokenizer_config["model_type"] = "vibevoice_acoustic_tokenizer"
+            self.acoustic_tokenizer_config = self.sub_configs["acoustic_tokenizer_config"](**acoustic_tokenizer_config)
+        elif isinstance(acoustic_tokenizer_config, VibeVoiceAcousticTokenizerConfig):
+            # If an instance of the config class is provided
+            self.acoustic_tokenizer_config = acoustic_tokenizer_config
+
+        if semantic_tokenizer_config is None:
+            self.semantic_tokenizer_config = self.sub_configs["semantic_tokenizer_config"]()
+        elif isinstance(semantic_tokenizer_config, dict):
+            semantic_tokenizer_config["model_type"] = "vibevoice_semantic_tokenizer"
+            self.semantic_tokenizer_config = self.sub_configs["semantic_tokenizer_config"](**semantic_tokenizer_config)
+        elif isinstance(semantic_tokenizer_config, VibeVoiceSemanticTokenizerConfig):
+            # If an instance of the config class is provided
+            self.semantic_tokenizer_config = semantic_tokenizer_config
+
+        if decoder_config is None:
+            self.decoder_config = self.sub_configs["decoder_config"]()
+        elif isinstance(decoder_config, dict):
+            model_type = decoder_config.get("model_type", "")
+            if model_type == "qwen2":
+                self.decoder_config = Qwen2Config(**decoder_config)
+            elif model_type == "qwen3" and Qwen3Config is not None:
+                self.decoder_config = Qwen3Config(**decoder_config)
+            else:
+                # Fallback: try Qwen2Config for unknown types (backward compat)
+                try:
+                    self.decoder_config = Qwen2Config(**decoder_config)
+                except Exception:
+                    raise ValueError(
+                        f"Unsupported decoder model type: '{model_type}'. "
+                        f"Supported: 'qwen2', 'qwen3'"
+                    )
+        elif isinstance(decoder_config, Qwen2Config):
+            self.decoder_config = decoder_config
+        elif Qwen3Config is not None and isinstance(decoder_config, Qwen3Config):
+            self.decoder_config = decoder_config
+        elif isinstance(decoder_config, PretrainedConfig):
+            # Accept any PretrainedConfig subclass (future-proof)
+            self.decoder_config = decoder_config
+
+        if diffusion_head_config is None:
+            self.diffusion_head_config = self.sub_configs["diffusion_head_config"]()
+        elif isinstance(diffusion_head_config, dict):
+            diffusion_head_config["model_type"] = "vibevoice_diffusion_head"
+            self.diffusion_head_config = self.sub_configs["diffusion_head_config"](**diffusion_head_config)
+        elif isinstance(diffusion_head_config, VibeVoiceDiffusionHeadConfig):
+            # If an instance of the config class is provided
+            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)
+
+        super().__init__(**kwargs)
+
+__all__ = [
+    "VibeVoiceAcousticTokenizerConfig", 
+    "VibeVoiceSemanticTokenizerConfig", 
+    "VibeVoiceDiffusionHeadConfig", 
+    "VibeVoiceConfig"
+]

VibeVoice-tpu/src/vibevoice/modular/modeling_vibevoice.py

@@ -0,0 +1,508 @@
+from dataclasses import dataclass
+from typing import Dict, List, Optional, Tuple, Union, Callable
+from tqdm import tqdm
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import torch.distributed as dist
+
+from transformers.models.auto import AutoModel, AutoModelForCausalLM
+
+from transformers.activations import ACT2FN
+from transformers.modeling_outputs import CausalLMOutput, BaseModelOutputWithPast, ModelOutput
+from transformers.models.llama.modeling_llama import LlamaRMSNorm
+from transformers import modeling_utils
+from transformers.modeling_utils import PreTrainedModel
+from transformers.modeling_flash_attention_utils import FlashAttentionKwargs
+from transformers.utils import logging
+
+
+from .modular_vibevoice_tokenizer import VibeVoiceTokenizerStreamingCache, VibeVoiceAcousticTokenizerModel, VibeVoiceSemanticTokenizerModel
+from .modular_vibevoice_diffusion_head import VibeVoiceDiffusionHead
+from vibevoice.schedule.dpm_solver import DPMSolverMultistepScheduler
+
+from .configuration_vibevoice import VibeVoiceConfig
+
+
+logger = logging.get_logger(__name__)
+
+if not hasattr(modeling_utils, "ALL_PARALLEL_STYLES") or modeling_utils.ALL_PARALLEL_STYLES is None:
+    modeling_utils.ALL_PARALLEL_STYLES = ["tp", "none", "colwise", "rowwise"]
+
+@dataclass
+class VibeVoiceCausalLMOutputWithPast(ModelOutput):
+    loss: Optional[torch.FloatTensor] = None
+    diffusion_loss: Optional[torch.FloatTensor] = None
+    speech_token_num: Optional[int] = None
+    logits: torch.FloatTensor = None
+    past_key_values: Optional[Tuple[Tuple[torch.FloatTensor]]] = None
+    hidden_states: Optional[Tuple[torch.FloatTensor, ...]] = None
+    attentions: Optional[Tuple[torch.FloatTensor, ...]] = None
+
+
+@dataclass
+class VibeVoiceGenerationOutput(ModelOutput):
+    """
+    Output type for VibeVoice generation.
+    
+    Args:
+        sequences (`torch.LongTensor` of shape `(batch_size, sequence_length)`):
+            The generated sequences. 
+        speech_outputs (`List[torch.FloatTensor]`, *optional*):
+            List of generated speech waveforms or latents for each speech segment.
+    """
+    sequences: torch.LongTensor = None
+    speech_outputs: Optional[List[torch.FloatTensor]] = None
+
+
+class SpeechConnector(nn.Module):
+    def __init__(self, input_dim, output_dim):
+        super().__init__()
+        self.fc1 = nn.Linear(input_dim, output_dim)
+        self.norm = LlamaRMSNorm(output_dim, eps=1e-6)
+        self.fc2 = nn.Linear(output_dim, output_dim)
+
+    def forward(self, features, **kwargs):    
+        x = self.fc1(features)
+        x = self.norm(x)
+        x = self.fc2(x)
+        return x
+
+
+# @auto_docstring
+class VibeVoicePreTrainedModel(PreTrainedModel):
+    config_class = VibeVoiceConfig
+    base_model_prefix = "model"
+    supports_gradient_checkpointing = True
+    _skip_keys_device_placement = "past_key_values"
+    _supports_cache_class = True
+    _supports_flash_attn_2 = True
+    _supports_sdpa = True
+    _supports_quantized_cache = True
+    _supports_static_cache = True
+    _supports_attention_backend = True
+
+    def _init_weights(self, module):
+        if isinstance(module, VibeVoiceDiffusionHead):
+            module.initialize_weights()
+            return
+
+        # Use the language model's initializer_range if available
+        if hasattr(self.config, 'language_model_config') and hasattr(self.config.language_model_config, 'initializer_range'):
+            std = self.config.language_model_config.initializer_range
+        elif hasattr(self.config, 'decoder_config') and hasattr(self.config.decoder_config, 'initializer_range'):
+            std = self.config.decoder_config.initializer_range
+        else:
+            std = 0.02  # Default value
+            
+        if isinstance(module, nn.Linear):
+            module.weight.data.normal_(mean=0.0, std=std)
+            if module.bias is not None:
+                module.bias.data.zero_()
+        elif isinstance(module, nn.LayerNorm):
+            module.weight.data.fill_(1.0)
+            module.bias.data.zero_()
+
+# @auto_docstring
+class VibeVoiceModel(VibeVoicePreTrainedModel):
+    def __init__(self, config):
+        super().__init__(config)
+        
+        if hasattr(config, 'torch_dtype') and config.torch_dtype is not None:
+            if isinstance(config.torch_dtype, str):
+                dtype = getattr(torch, config.torch_dtype)
+            else:
+                dtype = config.torch_dtype
+        else:
+            dtype = torch.float32
+        
+        # Initialize Qwen2 model for language modeling
+        lm_config = config.decoder_config 
+        self.language_model = AutoModel.from_config(lm_config)
+        
+        # Initialize speech components if needed
+        self.acoustic_tokenizer = AutoModel.from_config(config.acoustic_tokenizer_config).to(dtype)
+        self.semantic_tokenizer = AutoModel.from_config(config.semantic_tokenizer_config).to(dtype)
+
+        self.acoustic_connector = SpeechConnector(config.acoustic_vae_dim, lm_config.hidden_size).to(dtype)
+        self.semantic_connector = SpeechConnector(config.semantic_vae_dim, lm_config.hidden_size).to(dtype)
+        
+        # Register scaling factors as buffers - use 1D tensors for FSDP compatibility
+        self.register_buffer('speech_scaling_factor', torch.tensor(float('nan')))  
+        self.register_buffer('speech_bias_factor', torch.tensor(float('nan')))
+
+        # Initialize prediction head for speech generation
+        self.prediction_head = AutoModel.from_config(config.diffusion_head_config).to(dtype)
+
+        # Initialize noise scheduler
+        self.noise_scheduler = DPMSolverMultistepScheduler(
+            num_train_timesteps=config.diffusion_head_config.ddpm_num_steps,
+            beta_schedule=config.diffusion_head_config.ddpm_beta_schedule,
+            prediction_type=config.diffusion_head_config.prediction_type
+        )
+    
+    def get_input_embeddings(self):
+        if hasattr(self.language_model, 'embed_tokens'):
+            # If the language model has an embed_tokens attribute, return it
+            return self.language_model.embed_tokens
+        
+        for name, attr in self.language_model.fullmap.items(): # parallel by nnscaler, the name is changed
+            if attr.orig_name == 'embed_tokens.weight':
+                return getattr(self.language_model, name)
+        assert False, 'should not arrive here'
+
+    def set_input_embeddings(self, value):
+        self.language_model.embed_tokens = value
+    
+    def set_speech_tokenizers(self, acoustic_tokenizer=None, semantic_tokenizer=None):
+        """Set the speech tokenizers used for encoding and decoding speech."""
+        self.acoustic_tokenizer = acoustic_tokenizer
+        self.semantic_tokenizer = semantic_tokenizer
+        
+        # Reset the encoder to evaluation mode
+        if self.acoustic_tokenizer is not None:
+            self.acoustic_tokenizer.eval()
+            
+        if self.semantic_tokenizer is not None:
+            self.semantic_tokenizer.eval()
+    
+    def forward(
+        self,
+        input_ids: torch.LongTensor = None,
+        attention_mask: Optional[torch.Tensor] = None,
+        position_ids: Optional[torch.LongTensor] = None,
+        past_key_values: Optional[Tuple[Tuple[torch.FloatTensor]]] = None,
+        inputs_embeds: Optional[torch.FloatTensor] = None,
+        use_cache: Optional[bool] = None,
+        output_attentions: Optional[bool] = None,
+        output_hidden_states: Optional[bool] = None,
+        return_dict: Optional[bool] = None,
+        cache_position: Optional[torch.LongTensor] = None,
+        **kwargs,
+    ) -> Union[Tuple, BaseModelOutputWithPast]:
+        
+        return_dict = return_dict if return_dict is not None else self.config.use_return_dict
+        
+        # Forward through language model
+        outputs = self.language_model(
+            input_ids=input_ids,
+            attention_mask=attention_mask,
+            position_ids=position_ids,
+            past_key_values=past_key_values,
+            inputs_embeds=inputs_embeds,
+            use_cache=use_cache,
+            output_attentions=output_attentions,
+            output_hidden_states=output_hidden_states,
+            return_dict=return_dict,
+            cache_position=cache_position,
+            **kwargs,
+        )
+        
+        if not return_dict:
+            return outputs
+            
+        return BaseModelOutputWithPast(
+            last_hidden_state=outputs.last_hidden_state,
+            past_key_values=outputs.past_key_values,
+            hidden_states=outputs.hidden_states,
+            attentions=outputs.attentions,
+        )
+
+
+class VibeVoiceForConditionalGeneration(VibeVoicePreTrainedModel):
+    _tied_weights_keys = ["lm_head.weight"]
+    _tp_plan = {"lm_head": "colwise_rep"}
+
+    def __init__(self, config):
+        super().__init__(config)
+        self.model = VibeVoiceModel(config)
+        self.vocab_size = config.decoder_config.vocab_size
+        self.lm_head = nn.Linear(config.decoder_config.hidden_size, self.vocab_size, bias=False)
+
+        self.post_init()
+        
+    def get_input_embeddings(self):
+        return self.model.get_input_embeddings()
+
+    def set_input_embeddings(self, value):
+        self.model.set_input_embeddings(value)
+
+    def get_output_embeddings(self):
+        return self.lm_head
+
+    def set_decoder(self, decoder):
+        self.model.language_model = decoder
+
+    def get_decoder(self):
+        return self.model.language_model
+
+    def tie_weights(self):
+        """
+        Tie the weights between the input embeddings and the output embeddings.
+        """
+        if getattr(self.config.decoder_config, 'tie_word_embeddings', False):
+            # The standard PreTrainedModel method will handle the tying.
+            # It typically does a simple parameter object assignment, which is
+            # CORRECT to do BEFORE FSDP wraps the model.
+            output_embeddings = self.get_output_embeddings()
+            input_embeddings = self.get_input_embeddings()
+            if hasattr(input_embeddings, 'weight'):
+                output_embeddings.weight = input_embeddings.weight
+            else:
+                # maybe returned input_embeddings a tensor directly
+                output_embeddings.weight = input_embeddings
+
+            if getattr(output_embeddings, "bias", None) is not None:
+                output_embeddings.bias.data = nn.functional.pad(
+                    output_embeddings.bias.data,
+                    (0, output_embeddings.weight.shape[0] - output_embeddings.bias.shape[0]),
+                    "constant",
+                    0,
+                )
+            print("✅ Tied input and output embeddings using standard assignment.")
+        else:
+            print("ℹ️  tie_word_embeddings is False, not tying weights.")
+
+    # Also, ensure set_output_embeddings is safe, though your implementation looks okay.
+    # The key is to avoid calling it after accelerator.prepare().
+    def set_output_embeddings(self, new_embeddings):
+        # Your current implementation using data.copy_ is good practice,
+        # but the best way is to not call this after prepare().
+        self.lm_head = new_embeddings
+
+    def forward_speech_features(
+            self, 
+            speech_tensors=None, 
+            speech_masks=None, 
+            speech_type="audio", 
+            return_unmask=False
+        ):
+        if speech_tensors is None:
+            # Use config to get vae_dim instead of non-existent self.args
+            vae_dim = self.config.acoustic_tokenizer_config.vae_dim
+            audio_features = torch.zeros(1, 1, vae_dim).to(self.get_input_embeddings().weight)
+            connect_features = self.model.acoustic_connector(audio_features)
+            return audio_features, connect_features
+        else:
+            with torch.no_grad():
+                if speech_type == "audio":
+                    with torch.no_grad():
+                        frames = self.model.acoustic_tokenizer.encode(speech_tensors.unsqueeze(1))[0][0]
+                    audio_tokens = frames.sample(self.model.acoustic_tokenizer.std_dist_type)[0]
+
+                elif speech_type == "vae":
+                    # Use config to get vae_dim instead of non-existent self.args
+                    vae_dim = self.config.acoustic_tokenizer_config.vae_dim
+                    speech_mode = speech_tensors.reshape(speech_tensors.size(0), -1, vae_dim)
+
+                    # gaussian sample from the speech_mode
+                    batch_size = speech_mode.size(0)
+                    value = self.model.acoustic_tokenizer.fix_std / 0.8
+                    std = torch.randn(batch_size, dtype=speech_mode.dtype, device=speech_mode.device) * value
+                    std = std.view(-1, *[1] * (speech_mode.dim() - 1))
+                    audio_tokens = speech_mode + std * torch.randn(speech_mode.shape).to(speech_mode)
+                else:
+                    raise NotImplementedError(f"Speech type {speech_type} not implemented")
+                
+                if torch.isnan(self.model.speech_scaling_factor) or torch.isnan(self.model.speech_bias_factor):
+                    scaling_factor = 1. / audio_tokens[speech_masks].flatten().std()
+                    bias_factor = -audio_tokens[speech_masks].flatten().mean()
+                    
+                    # Only use distributed operations if the process group is initialized
+                    if dist.is_available() and dist.is_initialized():
+                        dist.all_reduce(scaling_factor, op=dist.ReduceOp.SUM)
+                        dist.all_reduce(bias_factor, op=dist.ReduceOp.SUM)
+                        world_size = dist.get_world_size()
+                        self.model.speech_scaling_factor.copy_(scaling_factor / world_size)  
+                        self.model.speech_bias_factor.copy_(bias_factor / world_size)
+                        print(f"Speech scaling factor (distributed): {self.model.speech_scaling_factor}, bias factor: {self.model.speech_bias_factor}", flush=True)
+                    else:
+                        # Single process case
+                        self.model.speech_scaling_factor.copy_(scaling_factor)  
+                        self.model.speech_bias_factor.copy_(bias_factor)
+                        print(f"Speech scaling factor (single process): {self.model.speech_scaling_factor}, bias factor: {self.model.speech_bias_factor}", flush=True)
+                    
+                audio_features = (audio_tokens + self.model.speech_bias_factor) * self.model.speech_scaling_factor
+            
+            connect_features = self.model.acoustic_connector(audio_features)
+            if return_unmask:
+                return audio_features, connect_features
+            return audio_features[speech_masks], connect_features[speech_masks]
+        
+    def forward(
+        self,
+        input_ids: torch.LongTensor = None,
+        attention_mask: Optional[torch.Tensor] = None,
+        position_ids: Optional[torch.LongTensor] = None,
+        past_key_values: Optional[List[torch.FloatTensor]] = None,
+        inputs_embeds: Optional[torch.FloatTensor] = None,
+        labels: Optional[torch.LongTensor] = None,
+        use_cache: Optional[bool] = False,
+        output_attentions: Optional[bool] = None,
+        output_hidden_states: Optional[bool] = None,
+        return_dict: Optional[bool] = None,
+        cache_position: Optional[torch.LongTensor] = None,
+        # New arguments for speech processing and loss calculation
+        speech_tensors: Optional[torch.FloatTensor] = None,
+        speech_masks: Optional[torch.BoolTensor] = None,
+        speeches_loss_input: Optional[torch.FloatTensor] = None,
+        speech_semantic_tensors: Optional[torch.FloatTensor] = None, 
+        acoustic_input_mask: Optional[torch.BoolTensor] = None,
+        acoustic_loss_mask: Optional[torch.BoolTensor] = None,
+        ddpm_batch_mul: int = 1,
+        **kwargs: Optional[Dict[str, Union[torch.Tensor, str]]],
+        ) -> Union[Tuple, VibeVoiceCausalLMOutputWithPast]:
+        
+        return_dict = return_dict if return_dict is not None else self.config.use_return_dict
+        
+        x = self.get_input_embeddings()(input_ids)
+
+        semantic_speech_all_connect_features = self.model.semantic_connector(speech_semantic_tensors)
+        if speeches_loss_input is not None:
+            # only part audio need diffuse
+            speech_all_features, speech_all_connect_features = self.forward_speech_features(
+                    speech_tensors=speech_tensors.type_as(x) if speech_tensors is not None else None,
+                    speech_masks=speech_masks,
+                    speech_type=kwargs.get("speech_type", "audio"),
+                    return_unmask=True
+                )
+            if speech_tensors is not None:
+                if semantic_speech_all_connect_features is not None:
+                    x[acoustic_input_mask] = speech_all_connect_features[speech_masks] + semantic_speech_all_connect_features[speech_masks]
+                else:
+                    x[acoustic_input_mask] = speech_all_connect_features[speech_masks]
+                speech_features = speech_all_features[speeches_loss_input & speech_masks] # only part audio need diffuse
+                speech_connect_features = speech_all_connect_features[speeches_loss_input & speech_masks]
+                # Forward-time consistency check: selected latent count should match number of acoustic placeholders
+                try:
+                    if acoustic_input_mask is not None:
+                        assert speech_connect_features.shape[0] == int(acoustic_input_mask.sum().item()), (
+                            f"Mismatch between selected speech connectors ({speech_connect_features.shape[0]}) and acoustic_input_mask sum ({int(acoustic_input_mask.sum().item())})"
+                        )
+                except Exception:
+                    pass
+        else:
+            speech_features, speech_connect_features = self.forward_speech_features(
+                    speech_tensors=speech_tensors.type_as(x) if speech_tensors is not None else None,
+                    speech_masks=speech_masks,
+                    speech_type=kwargs.get("speech_type", "audio"),
+                )
+            if speech_tensors is not None:
+                x[acoustic_input_mask] = speech_connect_features
+
+        outputs = self.model(
+            input_ids=None,
+            attention_mask=attention_mask,
+            position_ids=position_ids,
+            past_key_values=past_key_values,
+            inputs_embeds=x,
+            use_cache=use_cache,
+            output_attentions=output_attentions,
+            output_hidden_states=False,
+            return_dict=return_dict,
+            cache_position=cache_position,
+        )
+
+        hidden_states = outputs.last_hidden_state
+        logits = self.lm_head(hidden_states)
+        # logits = logits.float()
+
+        loss = None
+        if labels is not None:
+            # The custom CE loss with masking is calculated in the training script.
+            # We leave the standard loss calculation here as None.
+            pass
+
+        # --- Diffusion Loss Calculation ---
+        diffusion_loss = None
+        # This block is executed only if we are in a context that involves speech.
+        if speech_tensors is not None and acoustic_loss_mask.sum().item() > 0:
+            # Build conditioning mask from positions whose NEXT token is a speech latent (shift left by 1)
+            cond_mask = torch.zeros_like(acoustic_loss_mask, dtype=torch.bool)
+            cond_mask[:, :-1] = acoustic_loss_mask[:, 1:]
+            cond_mask[:, 0] = False
+            condition_features = hidden_states[cond_mask]
+            
+            speech_len, latent_size = speech_features.shape
+            # Sanity check: ensure 1:1 alignment between selected conditions and latents
+            try:
+                assert condition_features.shape[0] == speech_len, (
+                    f"Mismatch: condition_features={condition_features.shape[0]} vs speech_features={speech_len}"
+                )
+            except Exception:
+                pass
+            
+            noise = torch.randn(
+                (speech_len * ddpm_batch_mul, latent_size),
+                device=hidden_states.device,
+                dtype=hidden_states.dtype
+            )
+            
+            timesteps = torch.multinomial(
+                torch.ones(self.config.diffusion_head_config.ddpm_num_steps),
+                speech_len * ddpm_batch_mul,
+                replacement=True,
+            ).to(hidden_states.device)
+
+            speech_features_repeated = speech_features.repeat_interleave(ddpm_batch_mul, dim=0)
+            condition_features_repeated = condition_features.repeat_interleave(ddpm_batch_mul, dim=0)
+
+            noisy_speech_features = self.model.noise_scheduler.add_noise(
+                speech_features_repeated, noise, timesteps
+            )
+            
+            model_output = self.model.prediction_head(
+                noisy_speech_features, 
+                timesteps.type_as(x), 
+                condition_features_repeated
+            )
+
+            prediction_type = self.config.diffusion_head_config.prediction_type
+            if prediction_type == "epsilon":
+                target_for_loss = noise
+            elif prediction_type == "v_prediction":
+                target_for_loss = self.model.noise_scheduler.get_velocity(
+                    speech_features_repeated, noise, timesteps
+                )
+            else:
+                raise NotImplementedError(f"Prediction type {prediction_type} not implemented")
+
+            diffusion_loss = F.mse_loss(model_output.float(), target_for_loss.float(), reduction='sum')
+            if latent_size > 0 and ddpm_batch_mul > 0:
+                # Normalize by latent dim, number of sampled diffusion steps per latent, and number of speech tokens
+                diffusion_loss = diffusion_loss / latent_size / ddpm_batch_mul / max(speech_len, 1)
+            else:
+                diffusion_loss = torch.tensor(0.0, device=diffusion_loss.device)
+        
+        else:
+            # Dummy loss for DDP to work when there are no speech samples in a batch,
+            # but we are in a speech context.
+            diffusion_loss = sum(p.sum() for p in self.model.prediction_head.parameters()) * 0.0
+            diffusion_loss += sum(p.sum() for p in self.model.acoustic_connector.parameters()) * 0.0
+            diffusion_loss += sum(p.sum() for p in self.model.semantic_connector.parameters()) * 0.0
+        # --- End Diffusion Loss Calculation ---
+
+        if not return_dict:
+            output = (logits, speech_len) + outputs.to_tuple()[1:]
+            return (loss, diffusion_loss) + output
+
+        return VibeVoiceCausalLMOutputWithPast(
+            loss=loss,
+            diffusion_loss=diffusion_loss,
+            speech_token_num=speech_len if speech_tensors is not None else 0,
+            logits=logits,
+            past_key_values=outputs.past_key_values,
+            hidden_states=outputs.hidden_states,
+            attentions=outputs.attentions,
+        )
+
+AutoModel.register(VibeVoiceConfig, VibeVoiceModel)
+AutoModelForCausalLM.register(VibeVoiceConfig, VibeVoiceForConditionalGeneration)
+
+__all__ = [
+    "VibeVoiceModel",
+    "VibeVoicePreTrainedModel",
+    "VibeVoiceForConditionalGeneration",
+    "VibeVoiceCausalLMOutputWithPast",
+    "VibeVoiceGenerationOutput",
+]

VibeVoice-tpu/src/vibevoice/modular/modeling_vibevoice_inference.py

@@ -0,0 +1,729 @@
+from dataclasses import dataclass
+from typing import Dict, List, Optional, Tuple, Union, Callable
+from tqdm import tqdm
+import torch
+import torch.nn as nn
+
+from transformers.models.auto import AutoModel, AutoModelForCausalLM
+
+from transformers.generation import GenerationMixin, GenerationConfig, LogitsProcessor, LogitsProcessorList, StoppingCriteriaList
+from transformers.modeling_outputs import BaseModelOutputWithPast, ModelOutput
+from transformers import modeling_utils
+from transformers.modeling_utils import PreTrainedModel
+from transformers.modeling_flash_attention_utils import FlashAttentionKwargs
+from transformers.utils import logging
+
+
+# from .modular_vibevoice_tokenizer import VibeVoiceTokenizerStreamingCache, VibeVoiceAcousticTokenizerModel, VibeVoiceSemanticTokenizerModel
+from .modular_vibevoice_tokenizer import VibeVoiceTokenizerStreamingCache, VibeVoiceTokenizerEncoderOutput
+from .modular_vibevoice_diffusion_head import VibeVoiceDiffusionHead
+from vibevoice.schedule.dpm_solver import DPMSolverMultistepScheduler
+
+from .configuration_vibevoice import VibeVoiceConfig
+
+from .modular_vibevoice_text_tokenizer import VibeVoiceTextTokenizer, VibeVoiceTextTokenizerFast
+
+from .modeling_vibevoice import VibeVoiceModel, VibeVoicePreTrainedModel
+from .streamer import AudioStreamer, AsyncAudioStreamer
+
+# DynamicCache compatibility shim (transformers >= 4.43)
+try:
+    from transformers.cache_utils import DynamicCache
+    _HAS_DYNAMIC_CACHE = True
+except ImportError:
+    _HAS_DYNAMIC_CACHE = False
+
+logger = logging.get_logger(__name__)
+
+if not hasattr(modeling_utils, "ALL_PARALLEL_STYLES") or modeling_utils.ALL_PARALLEL_STYLES is None:
+    modeling_utils.ALL_PARALLEL_STYLES = ["tp", "none", "colwise", "rowwise"]
+
+@dataclass
+class VibeVoiceCausalLMOutputWithPast(BaseModelOutputWithPast):
+    logits: Optional[torch.FloatTensor] = None
+
+@dataclass
+class VibeVoiceGenerationOutput(ModelOutput):
+    """
+    Output type for VibeVoice generation.
+    
+    Args:
+        sequences (`torch.LongTensor` of shape `(batch_size, sequence_length)`):
+            The generated sequences. 
+        speech_outputs (`List[torch.FloatTensor]`, *optional*):
+            List of generated speech waveforms or latents for each speech segment.
+    """
+    sequences: torch.LongTensor = None
+    speech_outputs: Optional[List[torch.FloatTensor]] = None
+    reach_max_step_sample: Optional[torch.BoolTensor] = None
+
+class VibeVoiceTokenConstraintProcessor(LogitsProcessor):
+    """Constrains token generation to only valid tokens during speech generation."""
+    
+    def __init__(self, valid_token_ids: List[int], device: torch.device = None):
+        self.valid_token_ids = torch.tensor(valid_token_ids, dtype=torch.long, device=device)
+        
+    def __call__(self, input_ids: torch.LongTensor, scores: torch.FloatTensor) -> torch.FloatTensor:
+        # Create a mask for valid tokens
+        mask = torch.full_like(scores, float('-inf'))
+        mask[:, self.valid_token_ids] = 0
+        
+        # Apply mask to scores
+        scores = scores + mask
+        return scores
+    
+class VibeVoiceForConditionalGenerationInference(VibeVoicePreTrainedModel, GenerationMixin):
+    _tied_weights_keys = ["lm_head.weight"]
+    _tp_plan = {"lm_head": "colwise_rep"}
+
+    def __init__(self, config):
+        super().__init__(config)
+        
+        # Initialize the base model
+        self.model = VibeVoiceModel(config)
+        
+        # LM head for text generation
+        self.lm_head = nn.Linear(config.decoder_config.hidden_size, config.decoder_config.vocab_size, bias=False)
+        
+        # inference configuration
+        self.ddpm_inference_steps = config.diffusion_head_config.ddpm_num_inference_steps
+
+        # Initialize weights and apply final processing
+        self.post_init()
+
+    @property
+    def noise_scheduler(self):
+        return self.model.noise_scheduler
+
+    @property
+    def prediction_head(self):
+        return self.model.prediction_head
+    
+    @property
+    def speech_scaling_factor(self):
+        return self.model.speech_scaling_factor
+
+    @property
+    def speech_bias_factor(self):
+        return self.model.speech_bias_factor
+
+    @property
+    def acoustic_tokenizer(self):
+        return self.model.acoustic_tokenizer
+
+    @property
+    def semantic_tokenizer(self):
+        return self.model.semantic_tokenizer
+    
+    @property
+    def acoustic_connector(self):
+        return self.model.acoustic_connector
+
+    @property
+    def semantic_connector(self):
+        return self.model.semantic_connector
+        
+    def tie_weights(self):
+        """
+        Tie the weights between the input embeddings and the output embeddings.
+        """
+        # Tie lm_head.weight to language_model.embed_tokens.weight
+        if not getattr(self.config, 'tie_word_embeddings', False):
+            return
+         
+        if hasattr(self, 'lm_head') and hasattr(self.model.language_model, 'embed_tokens'):
+            self.lm_head.weight = self.model.language_model.embed_tokens.weight
+        
+    def get_input_embeddings(self):
+        return self.model.get_input_embeddings()
+    
+    def set_input_embeddings(self, value):
+        self.model.set_input_embeddings(value)
+    
+    def get_output_embeddings(self):
+        return self.lm_head
+    
+    def set_output_embeddings(self, new_embeddings):
+        self.lm_head = new_embeddings
+    
+    def set_speech_tokenizers(self, acoustic_tokenizer=None, semantic_tokenizer=None):
+        """Set the speech tokenizers used for encoding and decoding speech."""
+        self.model.set_speech_tokenizers(acoustic_tokenizer, semantic_tokenizer)
+    
+    def set_ddpm_inference_steps(self, num_steps=None):
+        self.ddpm_inference_steps = num_steps or self.config.diffusion_head_config.ddpm_num_inference_steps
+
+    def _process_speech_inputs(self, speech_tensors, speech_masks, speech_type="audio"):
+        """Process speech inputs through tokenizers and connectors."""
+        with torch.no_grad():
+            if speech_type == "audio":
+                # Encode audio to acoustic latents
+                encoder_output = self.model.acoustic_tokenizer.encode(speech_tensors.unsqueeze(1))
+                acoustic_latents = encoder_output.sample(dist_type=self.model.acoustic_tokenizer.std_dist_type)[0]
+                
+                # Apply scaling and bias
+                acoustic_features = (acoustic_latents + self.model.speech_bias_factor.to(acoustic_latents.device)) * self.model.speech_scaling_factor.to(acoustic_latents.device)
+                
+                # Connect to language model space
+                acoustic_connected = self.model.acoustic_connector(acoustic_features)[speech_masks.cpu()]
+                
+                return acoustic_features, acoustic_connected
+            elif speech_type == "pt":
+                encoder_output = VibeVoiceTokenizerEncoderOutput(mean=speech_tensors, std=self.acoustic_tokenizer.config.fix_std)
+                acoustic_latents = encoder_output.sample(dist_type=self.model.acoustic_tokenizer.std_dist_type)[0]
+                
+                # Apply scaling and bias
+                acoustic_features = (acoustic_latents + self.model.speech_bias_factor.to(acoustic_latents.device)) * self.model.speech_scaling_factor.to(acoustic_latents.device)
+                
+                # Connect to language model space
+                acoustic_connected = self.model.acoustic_connector(acoustic_features)[speech_masks.cpu()]
+                
+                return acoustic_features, acoustic_connected
+            else:
+                raise NotImplementedError(f"Speech type {speech_type} not implemented")
+    
+    # @can_return_tuple
+    def forward(
+        self,
+        input_ids: torch.LongTensor = None,
+        attention_mask: Optional[torch.Tensor] = None,
+        position_ids: Optional[torch.LongTensor] = None,
+        past_key_values: Optional[Tuple[Tuple[torch.FloatTensor]]] = None,
+        inputs_embeds: Optional[torch.FloatTensor] = None,
+        labels: Optional[torch.LongTensor] = None,
+        use_cache: Optional[bool] = None,
+        output_attentions: Optional[bool] = None,
+        output_hidden_states: Optional[bool] = None,
+        return_dict: Optional[bool] = None,
+        cache_position: Optional[torch.LongTensor] = None,
+        speech_tensors: Optional[torch.FloatTensor] = None,
+        speech_masks: Optional[torch.BoolTensor] = None,
+        speech_input_mask: Optional[torch.BoolTensor] = None,
+        logits_to_keep: Union[int, slice] = 0,
+        **kwargs,
+    ) -> Union[Tuple, VibeVoiceCausalLMOutputWithPast]:
+        """
+        Args:
+            labels (`torch.LongTensor` of shape `(batch_size, sequence_length)`, *optional*):
+                Labels for computing the masked language modeling loss. Indices should either be in `[0, ...,
+                config.vocab_size]` or -100 (see `input_ids` docstring). Tokens with indices set to `-100` are ignored
+                (masked), the loss is only computed for the tokens with labels in `[0, ..., config.vocab_size]`.
+            speech_tensors (`torch.FloatTensor`, *optional*):
+                Input speech waveforms for voice cloning or speech understanding.
+            speech_masks (`torch.BoolTensor`, *optional*):
+                Masks indicating valid speech frames.
+            speech_input_mask (`torch.BoolTensor`, *optional*):
+                Positions in the input sequence where speech embeddings should be inserted.
+        
+        Returns:
+            `VibeVoiceCausalLMOutputWithPast` or tuple
+        """
+        return_dict = return_dict if return_dict is not None else self.config.use_return_dict
+        
+        # Get embeddings
+        if inputs_embeds is None:
+            inputs_embeds = self.model.get_input_embeddings()(input_ids)
+        
+        # Process speech inputs if provided
+        if speech_tensors is not None and speech_masks is not None:
+            acoustic_features, speech_embeds = self._process_speech_inputs(speech_tensors.to(self.dtype), speech_masks)
+            if speech_input_mask is not None:
+                inputs_embeds[speech_input_mask] = speech_embeds
+
+        outputs = self.model(
+            inputs_embeds=inputs_embeds,
+            attention_mask=attention_mask,
+            position_ids=position_ids,
+            past_key_values=past_key_values,
+            use_cache=use_cache,
+            output_attentions=output_attentions,
+            output_hidden_states=output_hidden_states,
+            return_dict=return_dict,
+            cache_position=cache_position,
+            **kwargs,
+        )
+
+        hidden_states = outputs[0] if not return_dict else outputs.last_hidden_state
+        # Only compute necessary logits, and do not upcast them to float if we are not computing the loss
+        slice_indices = slice(-logits_to_keep, None) if isinstance(logits_to_keep, int) else logits_to_keep
+        logits = self.lm_head(hidden_states[:, slice_indices, :])
+                
+        if labels is not None:
+            raise NotImplementedError("Loss computation is not implemented in this version.")
+
+        return VibeVoiceCausalLMOutputWithPast(
+            logits=logits,
+            past_key_values=outputs.past_key_values,
+            last_hidden_state=hidden_states,
+            attentions=outputs.attentions,
+        )
+
+    def _build_generate_config_model_kwargs(self, generation_config, inputs, tokenizer, return_processors=False, **kwargs):
+        if generation_config is None:
+            generation_config = GenerationConfig(
+                bos_token_id=tokenizer.bos_token_id,
+                eos_token_id=tokenizer.eos_token_id,
+                pad_token_id = tokenizer.pad_token_id
+            )
+        else:
+            generation_config = GenerationConfig(
+                **generation_config,
+                bos_token_id=tokenizer.bos_token_id,
+                eos_token_id=tokenizer.eos_token_id,
+                pad_token_id = tokenizer.pad_token_id
+            )
+
+        generation_config, model_kwargs = self._prepare_generation_config(
+            generation_config, 
+            True, 
+            speech_start_id=tokenizer.speech_start_id, 
+            speech_end_id=tokenizer.speech_end_id, 
+            speech_diffusion_id=tokenizer.speech_diffusion_id, 
+            **kwargs
+        )
+        generation_config.speech_start_id = tokenizer.speech_start_id
+        generation_config.speech_end_id = tokenizer.speech_end_id
+        generation_config.speech_diffusion_id = tokenizer.speech_diffusion_id
+
+        inputs_tensor, model_input_name, model_kwargs = self._prepare_model_inputs(inputs, generation_config.bos_token_id, model_kwargs)
+        batch_size = inputs_tensor.shape[0]
+        device = self.device
+        
+        self._prepare_special_tokens(generation_config, True, device=device)
+        generation_config.use_cache = True
+        model_kwargs["use_cache"] = generation_config.use_cache
+        input_ids = inputs_tensor.to(self.device)
+
+        input_ids_length = input_ids.shape[1]
+        has_default_max_length = kwargs.get("max_length") is None and generation_config.max_length is not None
+        has_default_min_length = kwargs.get("min_length") is None and generation_config.min_length is not None
+        generation_config = self._prepare_generated_length(
+            generation_config=generation_config,
+            has_default_max_length=has_default_max_length,
+            has_default_min_length=has_default_min_length,
+            model_input_name=model_input_name,
+            inputs_tensor=inputs_tensor,
+            input_ids_length=input_ids_length,
+        )
+
+        max_cache_length = generation_config.max_length - 1
+        self._prepare_cache_for_generation(generation_config, model_kwargs, None, batch_size, max_cache_length, device)
+        model_kwargs['cache_position'] = torch.arange(input_ids_length, device=device, dtype=torch.long)
+        for k, v in model_kwargs.items():
+            if isinstance(v, torch.Tensor):
+                model_kwargs[k] = v.to(device=device)
+        
+        if return_processors:
+            logits_processor = self._get_logits_processor(
+                generation_config=generation_config,
+                input_ids_seq_length=input_ids_length,
+                encoder_input_ids=inputs_tensor,
+                prefix_allowed_tokens_fn=None,
+                logits_processor=LogitsProcessorList(),
+                device=inputs_tensor.device,
+                model_kwargs=model_kwargs,
+            )
+
+            stopping_criteria = self._get_stopping_criteria(generation_config=generation_config, stopping_criteria=StoppingCriteriaList())
+        
+            return generation_config, model_kwargs, input_ids, logits_processor, stopping_criteria
+        else:
+            return generation_config, model_kwargs, input_ids
+        
+    @torch.no_grad()
+    def generate(
+        self,
+        inputs: Optional[torch.Tensor] = None,
+        generation_config: Optional[GenerationConfig] = None,
+        logits_processor: Optional[LogitsProcessorList] = None,
+        stopping_criteria: Optional[StoppingCriteriaList] = None,
+        prefix_allowed_tokens_fn: Optional[Callable[[int, torch.Tensor], List[int]]] = None,
+        synced_gpus: Optional[bool] = None,
+        assistant_model: Optional["PreTrainedModel"] = None,
+        audio_streamer: Optional[Union[AudioStreamer, AsyncAudioStreamer]] = None,
+        negative_prompt_ids: Optional[torch.Tensor] = None,
+        negative_prompt_attention_mask: Optional[torch.Tensor] = None,
+        speech_tensors: Optional[torch.FloatTensor] = None,
+        speech_masks: Optional[torch.BoolTensor] = None,
+        speech_input_mask: Optional[torch.BoolTensor] = None,
+        return_speech: bool = True,
+        cfg_scale: float = 1.0,
+        stop_check_fn: Optional[Callable[[], bool]] = None,
+        **kwargs,
+    ) -> Union[torch.LongTensor, VibeVoiceGenerationOutput]:
+        """
+        Generates sequences of token ids and optionally speech outputs.
+        
+        Args:
+            All standard generation arguments from GenerationMixin
+            negative_prompt_ids: Negative prompt for CFG in speech generation
+            negative_prompt_attention_mask: Attention mask for negative prompt
+            speech_tensors: Input speech for voice cloning
+            speech_masks: Masks for speech tensors  
+            speech_input_mask: Positions to insert speech embeddings
+            return_speech: Whether to decode and return speech outputs
+            cfg_scale: CFG scale for speech generation
+            stop_check_fn: Optional callable that returns True if generation should stop
+ 
+        Returns:
+            Generated token sequences and optionally speech outputs
+        """
+        # 1. Handle `generation_config` and kwargs that might update it, and validate the `.generate()` call
+        tokenizer = kwargs.pop("tokenizer", None)  # Pull this out first, we only use it for stopping criteria
+        parsed_scripts = kwargs.pop("parsed_scripts", None)
+        all_speakers_list = kwargs.pop("all_speakers_list", None)
+        max_length_times = kwargs.pop("max_length_times", 2)
+
+        if kwargs.get('max_new_tokens', None) is None:
+            kwargs['max_new_tokens'] = self.config.decoder_config.max_position_embeddings - kwargs['input_ids'].shape[-1]
+
+        generation_config, model_kwargs, input_ids, logits_processor, stopping_criteria = self._build_generate_config_model_kwargs(
+            generation_config, inputs, tokenizer, return_processors=True, **kwargs
+        )
+        
+        negative_kwargs = {
+            'input_ids': torch.full((kwargs['input_ids'].shape[0], 1), tokenizer.speech_start_id, dtype=torch.long, device=kwargs['input_ids'].device),
+            'attention_mask':  torch.ones((kwargs['input_ids'].shape[0], 1), dtype=torch.long, device=kwargs['input_ids'].device),
+            'max_new_tokens': kwargs.get('max_new_tokens', 100) 
+        }
+        negative_generation_config, negative_model_kwargs, negative_input_ids = self._build_generate_config_model_kwargs(
+            None, None, tokenizer, return_processors=False, **negative_kwargs
+        )
+
+        acoustic_cache = VibeVoiceTokenizerStreamingCache()
+        semantic_cache = VibeVoiceTokenizerStreamingCache()
+        
+        # Device resolution for multi-GPU compatibility
+        # acoustic_tokenizer and semantic_tokenizer may live on different GPUs
+        acoustic_device = next(self.model.acoustic_tokenizer.parameters()).device
+        semantic_device = next(self.model.semantic_tokenizer.parameters()).device
+        acoustic_connect_device = next(self.model.acoustic_connector.parameters()).device
+        semantic_connect_device = next(self.model.semantic_connector.parameters()).device
+        
+        batch_size = input_ids.shape[0]
+        device = input_ids.device
+        finished_tags = torch.zeros(batch_size, dtype=torch.bool, device=device)
+        correct_cnt = torch.zeros(batch_size, dtype=torch.long, device=device)
+        is_prefill = True
+        inputs_embeds = None
+        verbose = kwargs.get("verbose", False)
+
+        # Initialize audio chunks storage for each sample
+        audio_chunks = [[] for _ in range(batch_size)]
+
+        initial_length = input_ids.shape[-1]
+        initial_length_per_sample = model_kwargs['attention_mask'].sum(dim=-1)
+
+       # Define all valid tokens that can be generated
+        valid_tokens = [
+            generation_config.speech_start_id,
+            generation_config.speech_end_id, 
+            generation_config.speech_diffusion_id,
+            generation_config.eos_token_id
+        ]
+        # Add bos_token_id if it exists
+        if hasattr(generation_config, 'bos_token_id') and generation_config.bos_token_id is not None:
+            valid_tokens.append(generation_config.bos_token_id)
+        
+        # Add custom processor to constrain token generation
+        token_constraint_processor = VibeVoiceTokenConstraintProcessor(valid_tokens, device=device)
+        if logits_processor is None:
+            logits_processor = LogitsProcessorList()
+        logits_processor.append(token_constraint_processor)
+        
+        max_steps = min(generation_config.max_length - initial_length, int(max_length_times * initial_length))
+        max_step_per_sample = torch.minimum(generation_config.max_length - initial_length_per_sample, (max_length_times * initial_length_per_sample).long())
+        reach_max_step_sample = torch.zeros(batch_size, dtype=torch.bool, device=device)
+
+        # Create progress iterator if verbose
+        if kwargs.get("show_progress_bar", True):
+            progress_bar = tqdm(range(max_steps), desc="Generating", leave=False)
+        else:
+            progress_bar = range(max_steps)
+        
+        for step in progress_bar:
+            # Check for external stop signal
+            if stop_check_fn is not None and stop_check_fn():
+                if verbose:
+                    print(f"Generation stopped externally at step {step + 1}")
+                # End the audio streamer if it exists
+                if audio_streamer is not None:
+                    audio_streamer.end()
+                break
+            
+            # Check if audio_streamer has been ended (stopped externally)
+            if audio_streamer is not None and hasattr(audio_streamer, 'finished_flags'):
+                if any(audio_streamer.finished_flags):
+                    if verbose:
+                        print(f"Audio generation stopped externally at step {step + 1}")
+                    break
+            
+            if finished_tags.all():
+                if hasattr(progress_bar, 'set_description'):
+                    progress_bar.set_description("Generation complete")
+                break
+
+            if input_ids.shape[-1] >= generation_config.max_length:
+                print(f"Reached maximum generation length {generation_config.max_length}, stopped it.")
+                reached_samples = torch.arange(batch_size, device=device)[~finished_tags]
+                if reached_samples.numel() > 0:
+                    reach_max_step_sample[reached_samples] = True
+                break
+            
+            # Update progress bar description with active samples
+            if hasattr(progress_bar, 'set_description'):
+                active_samples = (~finished_tags).sum().item()
+                progress_bar.set_description(f"Generating (active: {active_samples}/{batch_size})")
+
+            model_inputs = self.prepare_inputs_for_generation(input_ids, **model_kwargs)
+            if is_prefill:
+                # we process the speech inputs only during the first generation step
+                prefill_inputs = {
+                    "speech_tensors": speech_tensors.to(device=device),
+                    "speech_masks": speech_masks.to(device),
+                    "speech_input_mask": speech_input_mask.to(device),
+                }
+                is_prefill = False
+            else:
+                _ = model_inputs.pop('inputs_embeds', None)
+                prefill_inputs = {'inputs_embeds': inputs_embeds}
+
+            # Forward pass through the model
+            outputs = self(
+                **model_inputs, **prefill_inputs, logits_to_keep=1, return_dict=True, output_attentions=False, output_hidden_states=False,
+            )
+            model_kwargs = self._update_model_kwargs_for_generation(
+                outputs, model_kwargs, is_encoder_decoder=False,
+            )
+
+            # Get logits and apply logits processor
+            next_token_logits = outputs.logits[:, -1, :].to(copy=True, dtype=torch.float32, device=input_ids.device)
+            # next_token_logits = outputs.logits[:, -1, :].to(copy=True, device=input_ids.device)
+            next_token_scores = logits_processor(input_ids, next_token_logits)
+            
+            # token selection
+            if generation_config.do_sample:
+                probs = nn.functional.softmax(next_token_scores, dim=-1)
+                # TODO (joao): this OP throws "skipping cudagraphs due to ['incompatible ops']", find solution
+                next_tokens = torch.multinomial(probs, num_samples=1).squeeze(1)
+            else:
+                next_tokens = torch.argmax(next_token_scores, dim=-1)
+
+            next_tokens[finished_tags] = generation_config.eos_token_id
+            input_ids = torch.cat([input_ids, next_tokens[:, None]], dim=-1)
+            
+            if not kwargs.get('refresh_negative', True):
+                negative_model_inputs = self.prepare_inputs_for_generation(negative_input_ids, **negative_model_kwargs)
+                # Forward negative pass through the model
+                if negative_model_inputs['inputs_embeds'] is None and inputs_embeds is not None:
+                    negative_model_inputs['inputs_embeds'] = inputs_embeds
+                    negative_model_inputs['input_ids'] = None
+
+                negative_outputs = self(
+                    **negative_model_inputs, logits_to_keep=0, return_dict=True, output_attentions=False, output_hidden_states=False,
+                )
+                negative_model_kwargs = self._update_model_kwargs_for_generation(
+                    negative_outputs, negative_model_kwargs, is_encoder_decoder=False,
+                )
+                negative_input_ids = torch.cat([negative_input_ids, next_tokens[:, None]], dim=-1)
+
+            # reached end of generation
+            if (next_tokens == generation_config.eos_token_id).any():
+                eos_indices = (next_tokens == generation_config.eos_token_id).nonzero(as_tuple=False).squeeze(1)
+                # Only print for samples that are newly finished (not already marked as finished)
+                new_eos_indices = eos_indices[~finished_tags[eos_indices]]
+                if new_eos_indices.numel() > 0:
+                    finished_tags[new_eos_indices] = True
+                    if verbose:
+                        print(f"Samples {new_eos_indices.tolist()} reached EOS token at step {step + 1}.", flush=True)
+                    if audio_streamer is not None:
+                        audio_streamer.end(new_eos_indices)
+
+            # Check if any sample reached its maximum generation length
+            max_length_reached = step >= max_step_per_sample
+            new_max_length_indices = torch.nonzero(max_length_reached & ~finished_tags, as_tuple=False).squeeze(1)
+            if new_max_length_indices.numel() > 0:
+                finished_tags[new_max_length_indices] = True
+                reach_max_step_sample[new_max_length_indices] = True
+                if verbose:
+                    print(f"Samples {new_max_length_indices.tolist()} reached max generation length at step {step + 1}.", flush=True)
+                if audio_streamer is not None:
+                    audio_streamer.end(new_max_length_indices)
+
+            # speech_end
+            diffusion_end_indices = (next_tokens == generation_config.speech_end_id).nonzero(as_tuple=False).squeeze(1)
+            if diffusion_end_indices.numel() > 0:
+                # Clear tokenizer caches for samples that reached speech end
+                acoustic_cache.set_to_zero(diffusion_end_indices)
+                semantic_cache.set_to_zero(diffusion_end_indices)
+            
+            # speech_begin
+            diffusion_start_indices = torch.arange(batch_size, device=device)[~finished_tags & (next_tokens == generation_config.speech_start_id)]
+            if diffusion_start_indices.numel() > 0 and kwargs.get('refresh_negative', True):
+                # update attention mask
+                for i, sample_idx in enumerate(diffusion_start_indices.tolist()):
+                    negative_model_kwargs['attention_mask'][sample_idx, :] = 0
+                    negative_model_kwargs['attention_mask'][sample_idx, -1] = 1
+                # update past key values
+                for layer_idx, (k_cache, v_cache) in enumerate(zip(negative_model_kwargs['past_key_values'].key_cache, 
+                                                                        negative_model_kwargs['past_key_values'].value_cache)):
+                    # Process each non-diffusion sample
+                    for sample_idx in diffusion_start_indices.tolist():
+                        # Shift cache for this sample
+                        k_cache[sample_idx, :, -1, :] = k_cache[sample_idx, :, 0, :].clone()
+                        v_cache[sample_idx, :, -1, :] = v_cache[sample_idx, :, 0, :].clone()
+                # update negative_input_ids
+                for sample_idx in diffusion_start_indices.tolist():
+                    negative_input_ids[sample_idx, -1] = generation_config.speech_start_id
+            
+            # Prepare inputs_embeds for next iteration
+            # Initialize with default embeddings for all tokens
+            next_inputs_embeds = self.model.get_input_embeddings()(next_tokens).unsqueeze(1)  # [batch_size, 1, hidden_size]
+            
+            # forward diffusion
+            # Diffusion indices are those that are not finished and not special tokens
+            diffusion_indices = torch.arange(batch_size, device=device)[~finished_tags & (next_tokens == generation_config.speech_diffusion_id)]
+            
+            if diffusion_indices.numel() > 0:
+                if kwargs.get('refresh_negative', True):
+                    negative_model_inputs = self.prepare_inputs_for_generation(negative_input_ids, **negative_model_kwargs)
+                    # Forward negative pass through the model
+                    if negative_model_inputs['inputs_embeds'] is None and inputs_embeds is not None:
+                        negative_model_inputs['inputs_embeds'] = inputs_embeds
+                        negative_model_inputs['input_ids'] = None
+
+                    negative_outputs = self(
+                        **negative_model_inputs, logits_to_keep=0, return_dict=True, output_attentions=False, output_hidden_states=False,
+                    )
+                    negative_model_kwargs = self._update_model_kwargs_for_generation(
+                        negative_outputs, negative_model_kwargs, is_encoder_decoder=False,
+                    )
+                    negative_input_ids = torch.cat([negative_input_ids, next_tokens[:, None]], dim=-1)
+                # correct the non-diffusion indices
+                # we forward all samples' negative outputs even if 
+                #   they are not in diffusion mode to keep the cache consistent
+                # So we need to correct the kv cache of non-diffusion samples
+                non_diffusion_mask = ~finished_tags & (next_tokens != generation_config.speech_diffusion_id)
+                if non_diffusion_mask.any():
+                    non_diffusion_indices = torch.arange(batch_size, device=device)[non_diffusion_mask]
+                    start_indices = correct_cnt[non_diffusion_indices]
+
+                    # 1. Update attention_mask - need to handle each sample separately
+                    seq_len = negative_model_kwargs['attention_mask'].shape[1]
+                    for i, (sample_idx, start_idx) in enumerate(zip(non_diffusion_indices.tolist(), start_indices.tolist())):
+                        # Shift the attention mask for this sample
+                        if start_idx + 1 < seq_len - 1:
+                            negative_model_kwargs['attention_mask'][sample_idx, start_idx+1:] = \
+                                negative_model_kwargs['attention_mask'][sample_idx, start_idx:-1].clone()
+                        negative_model_kwargs['attention_mask'][sample_idx, start_idx] = 0
+
+                    # 2. Update past_key_values
+                    for layer_idx, (k_cache, v_cache) in enumerate(zip(negative_model_kwargs['past_key_values'].key_cache, 
+                                                                        negative_model_kwargs['past_key_values'].value_cache)):
+                        # Process each non-diffusion sample
+                        for sample_idx, start_idx in zip(non_diffusion_indices.tolist(), start_indices.tolist()):
+                            if start_idx + 1 < k_cache.shape[2] - 1:
+                                # Shift cache for this sample
+                                k_cache[sample_idx, :, start_idx+1:, :] = k_cache[sample_idx, :, start_idx:-1, :].clone()
+                                v_cache[sample_idx, :, start_idx+1:, :] = v_cache[sample_idx, :, start_idx:-1, :].clone()
+                    
+                    # 3. Update negative_input_ids
+                    for sample_idx, start_idx in zip(non_diffusion_indices.tolist(), start_indices.tolist()):
+                        if start_idx + 1 < negative_input_ids.shape[1] - 1:
+                            negative_input_ids[sample_idx, start_idx+1:] = \
+                                negative_input_ids[sample_idx, start_idx:-1].clone()
+                                
+                    correct_cnt[non_diffusion_indices] += 1
+
+                positive_condition = outputs.last_hidden_state[diffusion_indices, -1, :]
+                negative_condition = negative_outputs.last_hidden_state[diffusion_indices, -1, :]
+                
+                speech_latent = self.sample_speech_tokens(
+                    positive_condition,
+                    negative_condition,
+                    cfg_scale=cfg_scale,
+                ).unsqueeze(1)
+                                
+                # Decode acoustic latent to audio using acoustic streaming cache
+                scaled_latent = speech_latent / self.model.speech_scaling_factor.to(speech_latent.device) - self.model.speech_bias_factor.to(speech_latent.device)
+                audio_chunk = self.model.acoustic_tokenizer.decode(
+                    scaled_latent.to(self.model.acoustic_tokenizer.device),
+                    cache=acoustic_cache,  # Use acoustic-specific cache
+                    sample_indices=diffusion_indices.to(self.model.acoustic_tokenizer.device),
+                    use_cache=True,
+                    debug=False
+                )
+                
+                # Store audio chunks for each sample
+                for i, sample_idx in enumerate(diffusion_indices):
+                    idx = sample_idx.item()
+                    # Only append audio chunk if the sample is not finished
+                    if not finished_tags[idx]:
+                        audio_chunks[idx].append(audio_chunk[i])
+
+                 # Add streaming support here
+                if audio_streamer is not None:
+                    # Stream the audio chunks immediately
+                    audio_streamer.put(audio_chunk, diffusion_indices)
+                    
+                # Encode audio to semantic features using semantic streaming cache
+                semantic_features = self.model.semantic_tokenizer.encode(
+                    audio_chunk,
+                    cache=semantic_cache,  # Use semantic-specific cache
+                    sample_indices=diffusion_indices,
+                    use_cache=True,
+                    debug=False
+                ).mean # semantic tokenizer has no VAE.
+                
+                # Combine acoustic and semantic features for next input
+                acoustic_embed = self.model.acoustic_connector(speech_latent)
+                semantic_embed = self.model.semantic_connector(semantic_features)
+                diffusion_embeds = acoustic_embed + semantic_embed
+
+                # Update embeddings for diffusion indices
+                next_inputs_embeds[diffusion_indices] = diffusion_embeds
+            
+            # Set inputs_embeds for next iteration
+            inputs_embeds = next_inputs_embeds
+
+        if audio_streamer is not None:
+            audio_streamer.end()
+
+        # Concatenate audio chunks for each sample
+        final_audio_outputs = []
+        for sample_chunks in audio_chunks:
+            if sample_chunks:
+                # Concatenate all chunks along the time dimension (assumed to be the last dimension)
+                concatenated_audio = torch.cat(sample_chunks, dim=-1)
+                final_audio_outputs.append(concatenated_audio)
+            else:
+                # If no audio was generated for this sample, append None
+                final_audio_outputs.append(None)
+
+        return VibeVoiceGenerationOutput(
+            sequences=input_ids,
+            speech_outputs=final_audio_outputs if return_speech else None,
+            reach_max_step_sample=reach_max_step_sample,
+        )
+    
+    @torch.no_grad()
+    def sample_speech_tokens(self, condition, neg_condition, cfg_scale=3.0):
+        self.model.noise_scheduler.set_timesteps(self.ddpm_inference_steps)
+        condition = torch.cat([condition, neg_condition], dim=0).to(self.model.prediction_head.device)
+        speech = torch.randn(condition.shape[0], self.config.acoustic_vae_dim).to(condition)
+        for t in self.model.noise_scheduler.timesteps:
+            half = speech[: len(speech) // 2]
+            combined = torch.cat([half, half], dim=0)
+            eps = self.model.prediction_head(combined, t.repeat(combined.shape[0]).to(combined), condition=condition)
+            cond_eps, uncond_eps = torch.split(eps, len(eps) // 2, dim=0)
+            half_eps = uncond_eps + cfg_scale * (cond_eps - uncond_eps)
+            eps = torch.cat([half_eps, half_eps], dim=0)
+            speech = self.model.noise_scheduler.step(eps, t, speech).prev_sample
+        return speech[: len(speech) // 2]
+    
+
+AutoModelForCausalLM.register(VibeVoiceConfig, VibeVoiceForConditionalGenerationInference)
+
+__all__ = [
+    "VibeVoiceForConditionalGenerationInference",
+]

VibeVoice-tpu/src/vibevoice/modular/modular_vibevoice_diffusion_head.py

@@ -0,0 +1,287 @@
+import math
+from typing import Optional, Tuple, Union
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+from transformers.models.auto import AutoModel
+from transformers.modeling_utils import PreTrainedModel
+# from transformers.modeling_layers import GradientCheckpointingLayer
+from transformers.activations import ACT2FN
+from transformers.utils import logging
+
+from .configuration_vibevoice import VibeVoiceDiffusionHeadConfig
+
+
+logger = logging.get_logger(__name__)
+
+
+class RMSNorm(nn.Module):
+    def __init__(self, dim: int, eps: float = 1e-6, elementwise_affine=True, memory_efficient=False):
+        super().__init__()
+        self.dim = dim
+        self.eps = eps
+        self.elementwise_affine = elementwise_affine
+        if self.elementwise_affine:
+            self.weight = nn.Parameter(torch.ones(dim))
+        else:
+            self.register_parameter('weight', None)
+
+    def _norm(self, x):
+        return x * torch.rsqrt(x.pow(2).mean(-1, keepdim=True) + self.eps)
+
+    def forward(self, x):
+        output = self._norm(x.float()).type_as(x)
+        if self.weight is not None:
+            output = output * self.weight
+        return output
+
+    def extra_repr(self) -> str:
+        return f'dim={self.dim}, eps={self.eps}, elementwise_affine={self.elementwise_affine}'
+    
+def modulate(x, shift, scale):
+    """Apply modulation to input tensor."""
+    return x * (1 + scale) + shift
+
+
+class TimestepEmbedder(nn.Module):
+    """
+    Embeds scalar timesteps into vector representations.
+    
+    Args:
+        hidden_size (`int`): Size of the output embedding
+        frequency_embedding_size (`int`, optional): Size of the intermediate frequency embedding
+    """
+    def __init__(self, hidden_size, frequency_embedding_size=256):
+        super().__init__()
+        self.mlp = nn.Sequential(
+            nn.Linear(frequency_embedding_size, hidden_size, bias=False),
+            # nn.SiLU(),
+            ACT2FN['silu'],
+            nn.Linear(hidden_size, hidden_size, bias=False),
+        )
+        self.frequency_embedding_size = frequency_embedding_size
+
+    @staticmethod
+    def timestep_embedding(t, dim, max_period=10000):
+        """
+        Create sinusoidal timestep embeddings.
+        
+        Args:
+            t (`torch.Tensor`): A 1-D Tensor of N indices, one per batch element.
+                            These may be fractional.
+            dim (`int`): The dimension of the output.
+            max_period (`int`, optional): Controls the minimum frequency of the embeddings.
+            
+        Returns:
+            `torch.Tensor`: An [N, D] Tensor of positional embeddings.
+        """
+        half = dim // 2
+        freqs = torch.exp(
+            -math.log(max_period) * torch.arange(start=0, end=half, dtype=torch.float32) / half
+        ).to(t.device)
+        args = t[:, None].float() * freqs[None]
+        embedding = torch.cat([torch.cos(args), torch.sin(args)], dim=-1)
+        if dim % 2:
+            embedding = torch.cat([embedding, torch.zeros_like(embedding[:, :1])], dim=-1)
+        return embedding.to(t.dtype)
+
+    def forward(self, t):
+        t_freq = self.timestep_embedding(t, self.frequency_embedding_size)
+        t_emb = self.mlp(t_freq)
+        return t_emb
+
+
+class FeedForwardNetwork(nn.Module):
+    """
+    Standard feed-forward network with SwiGLU activation.
+    
+    Args:
+        embed_dim (`int`): Input dimension
+        ffn_dim (`int`): Hidden dimension
+    """
+    def __init__(
+        self,
+        embed_dim,
+        ffn_dim,
+    ):
+        super().__init__()
+        self.embed_dim = embed_dim
+        self.gate_proj = nn.Linear(self.embed_dim, ffn_dim, bias=False)
+        self.up_proj = nn.Linear(self.embed_dim, ffn_dim, bias=False)
+        self.down_proj = nn.Linear(ffn_dim, self.embed_dim, bias=False)
+        self.act_fn = ACT2FN['silu']  # Using SiLU as the activation function
+
+    def forward(self, x):
+        gate = self.gate_proj(x)
+        up = self.up_proj(x)
+        
+        # SwiGLU activation
+        # gate = F.silu(gate)
+        gate = self.act_fn(gate)
+        return self.down_proj(gate * up)
+
+    
+class HeadLayer(nn.Module):
+    """
+    A layer in the diffusion head.
+    
+    Args:
+        embed_dim (`int`): Input dimension
+        ffn_dim (`int`): Hidden dimension
+        cond_dim (`int`): Condition embedding dimension
+        norm_eps (`float`, optional): Epsilon for normalization
+    """
+    def __init__(
+        self,
+        embed_dim,
+        ffn_dim,
+        cond_dim,
+        norm_eps=1e-5,
+    ):
+        super().__init__()
+        self.embed_dim = embed_dim
+        self.cond_dim = cond_dim
+        self.ffn_dim = ffn_dim
+        self.ffn = FeedForwardNetwork(
+            self.embed_dim,
+            self.ffn_dim,
+        )
+        self.norm = RMSNorm(self.embed_dim, eps=norm_eps)
+        self.adaLN_modulation = nn.Sequential(
+            # nn.SiLU(),
+            ACT2FN['silu'],
+            nn.Linear(cond_dim, 3 * self.embed_dim, bias=False)
+        )
+
+    def forward(self, x, c):
+        shift_ffn, scale_ffn, gate_ffn = self.adaLN_modulation(c).chunk(3, dim=-1)
+        x = x + gate_ffn * self.ffn(modulate(self.norm(x), shift_ffn, scale_ffn))
+        return x
+
+
+class FinalLayer(nn.Module):
+    """
+    Final layer in the diffusion head.
+    
+    Args:
+        hidden_size (`int`): Input dimension
+        output_size (`int`): Output dimension
+        cond_size (`int`): Condition embedding dimension
+        norm_eps (`float`, optional): Epsilon for normalization
+    """
+    def __init__(self, hidden_size, output_size, cond_size, norm_eps=1e-5):
+        super().__init__()
+        self.norm_final = RMSNorm(hidden_size, eps=norm_eps, elementwise_affine=False)
+        self.linear = nn.Linear(hidden_size, output_size, bias=False)
+        self.adaLN_modulation = nn.Sequential(
+            # nn.SiLU(),
+            ACT2FN['silu'],
+            nn.Linear(cond_size, 2 * hidden_size, bias=False)
+        )
+
+    def forward(self, x, c):
+        shift, scale = self.adaLN_modulation(c).chunk(2, dim=-1)
+        x = modulate(self.norm_final(x), shift, scale)
+        x = self.linear(x)
+        return x
+
+
+class VibeVoiceDiffusionHead(PreTrainedModel):
+    """
+    Diffusion head model for vibevoice.
+    
+    Args:
+        config (`VibeVoiceDiffusionHeadConfig`): Model configuration
+        latent_size (`int`, optional): Size of the latent space. If not provided, uses `config.latent_size`.
+    """
+    config_class = VibeVoiceDiffusionHeadConfig
+    supports_gradient_checkpointing = True
+    _supports_flash_attn_2 = True  
+    _supports_sdpa = True  
+    
+    def __init__(
+        self,
+        config,
+    ):
+        super().__init__(config)
+        self.config = config
+        self.cond_dim = config.hidden_size
+        latent_size = config.latent_size
+        
+        self.noisy_images_proj = nn.Linear(latent_size, config.hidden_size, bias=False)
+        self.cond_proj = nn.Linear(config.hidden_size, self.cond_dim, bias=False)
+        self.t_embedder = TimestepEmbedder(self.cond_dim)
+        
+        ffn_dim = int(config.hidden_size * config.head_ffn_ratio)
+        
+        # Create the intermediate layers
+        self.layers = nn.ModuleList([
+            HeadLayer(
+                embed_dim=config.hidden_size,
+                ffn_dim=ffn_dim,
+                cond_dim=self.cond_dim,
+                norm_eps=config.rms_norm_eps
+            )
+            for _ in range(config.head_layers)
+        ])
+        
+        # Final layer for output
+        self.final_layer = FinalLayer(
+            hidden_size=config.hidden_size, 
+            output_size=latent_size,
+            cond_size=self.cond_dim,
+            norm_eps=config.rms_norm_eps
+        )
+        
+        self.initialize_weights()
+
+    def initialize_weights(self):
+        """Initialize the weights of the model."""
+        # Initialize timestep embedder
+        nn.init.normal_(self.t_embedder.mlp[0].weight, std=0.02)
+        nn.init.normal_(self.t_embedder.mlp[2].weight, std=0.02)
+
+        # Zero-out adaLN modulation layers
+        for layer in self.layers:
+            nn.init.constant_(layer.adaLN_modulation[-1].weight, 0)
+
+        # Zero-out output layers
+        nn.init.constant_(self.final_layer.adaLN_modulation[-1].weight, 0)
+        nn.init.constant_(self.final_layer.linear.weight, 0)
+
+    def forward(
+        self,
+        noisy_images,
+        timesteps,
+        condition,
+    ):
+        """
+        Forward pass of the prediction head.
+        
+        Args:
+            noisy_images (`torch.Tensor`): Noisy images/latents to denoise
+            timesteps (`torch.Tensor`): Timesteps for diffusion
+            condition (`torch.Tensor`): Conditioning information
+            
+        Returns:
+            `torch.Tensor`: The predicted noise/velocity
+        """
+        x = self.noisy_images_proj(noisy_images)
+        t = self.t_embedder(timesteps)
+        condition = self.cond_proj(condition)
+        c = condition + t
+        
+        for layer in self.layers:
+            x = layer(x, c)
+            
+        x = self.final_layer(x, c)
+        return x
+
+
+AutoModel.register(VibeVoiceDiffusionHeadConfig, VibeVoiceDiffusionHead)
+
+__all__ = [
+    "VibeVoiceDiffusionHead",
+]

VibeVoice-tpu/src/vibevoice/modular/modular_vibevoice_text_tokenizer.py

@@ -0,0 +1,214 @@
+"""Tokenization classes for vibevoice."""
+
+from typing import List, Optional, Union
+
+from transformers.utils import logging
+from transformers.models.qwen2.tokenization_qwen2 import Qwen2Tokenizer
+from transformers.models.qwen2.tokenization_qwen2_fast import Qwen2TokenizerFast
+
+logger = logging.get_logger(__name__)
+
+
+class VibeVoiceTextTokenizer(Qwen2Tokenizer):
+    """
+    Construct a VibeVoice tokenizer. Based on the Qwen2 tokenizer with additional special tokens for speech.
+    
+    Args:
+        vocab_file (`str`):
+            Path to the vocabulary file.
+        merges_file (`str`):
+            Path to the merges file.
+        errors (`str`, *optional*, defaults to `"replace"`):
+            Paradigm to follow when decoding bytes to UTF-8.
+        unk_token (`str`, *optional*, defaults to `"<|endoftext|>"`):
+            The unknown token.
+        bos_token (`str`, *optional*):
+            The beginning of sequence token. Not used for vibevoice.
+        eos_token (`str`, *optional*, defaults to `"<|endoftext|>"`):
+            The end of sequence token.
+        pad_token (`str`, *optional*, defaults to `"<|endoftext|>"`):
+            The token used for padding.
+        add_special_tokens (`bool`, *optional*, defaults to `True`):
+            Whether or not to add special tokens when encoding.
+    """
+
+    model_input_names = ["input_ids", "attention_mask"]
+
+    def __init__(
+        self,
+        vocab_file,
+        merges_file,
+        errors="replace",
+        unk_token="<|endoftext|>",
+        bos_token=None,
+        eos_token="<|endoftext|>",
+        pad_token="<|endoftext|>",
+        add_prefix_space=False,
+        add_special_tokens=True,
+        **kwargs,
+    ):
+        super().__init__(
+            vocab_file=vocab_file,
+            merges_file=merges_file,
+            errors=errors,
+            unk_token=unk_token,
+            bos_token=bos_token,
+            eos_token=eos_token,
+            pad_token=pad_token,
+            add_prefix_space=add_prefix_space,
+            add_special_tokens=add_special_tokens,
+            **kwargs,
+        )
+        
+        # Add VibeVoice-specific special tokens
+        self._add_vibevoice_special_tokens()
+        
+    def _add_vibevoice_special_tokens(self):
+        """Add VibeVoice-specific special tokens."""
+        special_tokens = {
+            "additional_special_tokens": [
+                "<|vision_start|>",  # Speech start (reusing vision tokens)
+                "<|vision_end|>",  # Speech end
+                "<|vision_pad|>",  # Speech diffusion pad
+            ]
+        }
+        num_added = self.add_special_tokens(special_tokens)
+        
+        # Cache special token IDs
+        self._speech_start_id = self.convert_tokens_to_ids("<|vision_start|>")
+        self._speech_end_id = self.convert_tokens_to_ids("<|vision_end|>")
+        self._speech_diffusion_id = self.convert_tokens_to_ids("<|vision_pad|>")
+        
+        self._eos_id = self.convert_tokens_to_ids('<|endoftext|>')
+
+        return num_added
+    
+    @property
+    def eos_id(self) -> int:
+        """Id of the end of sequence token."""
+        return self._eos_id
+    
+    @property
+    def speech_start_id(self) -> int:
+        """Id of the speech start token."""
+        return self._speech_start_id
+    
+    @property
+    def speech_end_id(self) -> int:
+        """Id of the speech end token."""
+        return self._speech_end_id
+    
+    @property
+    def speech_diffusion_id(self) -> int:
+        """Id of the speech diffusion token."""
+        return self._speech_diffusion_id
+    
+    @property
+    def pad_id(self) -> int:
+        """Id used for padding (returns -100 for loss masking)."""
+        return -100
+
+
+class VibeVoiceTextTokenizerFast(Qwen2TokenizerFast):
+    """
+    Construct a "fast" VibeVoice tokenizer (backed by HuggingFace's *tokenizers* library).
+    Based on the Qwen2 tokenizer with additional special tokens for speech.
+    
+    Args:
+        vocab_file (`str`, *optional*):
+            Path to the vocabulary file.
+        merges_file (`str`, *optional*):
+            Path to the merges file.
+        tokenizer_file (`str`, *optional*):
+            Path to [tokenizers](https://github.com/huggingface/tokenizers) file.
+        unk_token (`str`, *optional*, defaults to `"<|endoftext|>"`):
+            The unknown token.
+        bos_token (`str`, *optional*):
+            The beginning of sequence token. Not used for vibevoice.
+        eos_token (`str`, *optional*, defaults to `"<|endoftext|>"`):
+            The end of sequence token.
+        pad_token (`str`, *optional*, defaults to `"<|endoftext|>"`):
+            The token used for padding.
+    """
+
+    model_input_names = ["input_ids", "attention_mask"]
+
+    def __init__(
+        self,
+        vocab_file=None,
+        merges_file=None,
+        tokenizer_file=None,
+        unk_token="<|endoftext|>",
+        bos_token=None,
+        eos_token="<|endoftext|>",
+        pad_token="<|endoftext|>",
+        add_prefix_space=False,
+        **kwargs,
+    ):
+        super().__init__(
+            vocab_file=vocab_file,
+            merges_file=merges_file,
+            tokenizer_file=tokenizer_file,
+            unk_token=unk_token,
+            bos_token=bos_token,
+            eos_token=eos_token,
+            pad_token=pad_token,
+            add_prefix_space=add_prefix_space,
+            **kwargs,
+        )
+        
+        # Add VibeVoice-specific special tokens
+        self._add_vibevoice_special_tokens()
+        
+    def _add_vibevoice_special_tokens(self):
+        """Add VibeVoice-specific special tokens."""
+        special_tokens = {
+            "additional_special_tokens": [
+                "<|vision_start|>",  # Speech start (reusing vision tokens)
+                "<|vision_end|>",  # Speech end
+                "<|vision_pad|>",  # Speech diffusion pad
+            ]
+        }
+        num_added = self.add_special_tokens(special_tokens)
+        
+        # Cache special token IDs
+        self._speech_start_id = self.convert_tokens_to_ids("<|vision_start|>")
+        self._speech_end_id = self.convert_tokens_to_ids("<|vision_end|>")
+        self._speech_diffusion_id = self.convert_tokens_to_ids("<|vision_pad|>")
+
+        # self._eos_id = self.convert_tokens_to_ids('<|endoftext|>')
+        self._eos_id = self.eos_token_id # qwen2 / qwen3
+        self._pad_id = self.convert_tokens_to_ids('<|image_pad|>')
+        
+        return num_added
+    
+    @property
+    def eos_id(self) -> int:
+        """Id of the end of sequence token."""
+        return self._eos_id
+    
+    @property
+    def speech_start_id(self) -> int:
+        """Id of the speech start token."""
+        return self._speech_start_id
+    
+    @property
+    def speech_end_id(self) -> int:
+        """Id of the speech end token."""
+        return self._speech_end_id
+    
+    @property
+    def speech_diffusion_id(self) -> int:
+        """Id of the speech diffusion token."""
+        return self._speech_diffusion_id
+    
+    @property
+    def pad_id(self) -> int:
+        """Id used for padding (returns -100 for loss masking)."""
+        return self._pad_id
+
+
+__all__ = [
+    "VibeVoiceTextTokenizer", 
+    "VibeVoiceTextTokenizerFast", 
+]

VibeVoice-tpu/src/vibevoice/modular/modular_vibevoice_tokenizer.py

@@ -0,0 +1,1195 @@
+import math
+import typing as tp
+from functools import partial
+from dataclasses import dataclass, field
+from typing import Dict, List, Optional, Tuple, Union
+import copy
+
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+from transformers.models.auto import AutoModel
+
+from transformers.configuration_utils import PretrainedConfig
+from transformers.utils import logging
+from transformers.modeling_utils import PreTrainedModel
+from transformers.activations import ACT2FN
+
+from .configuration_vibevoice import VibeVoiceAcousticTokenizerConfig, VibeVoiceSemanticTokenizerConfig
+
+logger = logging.get_logger(__name__)
+
+import os
+# Try to import APEX FusedRMSNorm
+try:
+    from apex.normalization.fused_layer_norm import fused_rms_norm_affine
+    APEX_AVAILABLE = True
+    logger.info("APEX FusedRMSNorm is available and will be used for optimization")
+    if int(os.getenv("OPTIMIZE_FOR_SPEED", "0")) == 0:
+        APEX_AVAILABLE = False
+        logger.warning("APEX FusedRMSNorm is disabled by environment variable OPTIMIZE_FOR_SPEED=0")
+except ImportError:
+    APEX_AVAILABLE = False
+    logger.warning("APEX FusedRMSNorm not available, using native implementation")
+# APEX_AVAILABLE=False
+
+# Normalization modules
+class ConvLayerNorm(nn.LayerNorm):
+    """
+    Convolution-friendly LayerNorm that moves channels to last dimensions
+    before running the normalization and moves them back to original position right after.
+    """
+    def __init__(self, normalized_shape: tp.Union[int, tp.List[int], torch.Size], **kwargs):
+        super().__init__(normalized_shape, **kwargs)
+
+    def forward(self, x):
+        x = x.transpose(1, 2)  # b ... t -> b t ...
+        x = nn.functional.layer_norm(x.float(), self.normalized_shape, self.weight.float(), self.bias.float(), self.eps).type_as(x) 
+        x = x.transpose(1, 2)  # b t ... -> b ... t
+        return x
+    
+class RMSNorm(nn.Module):
+    def __init__(self, dim: int, eps: float = 1e-5, elementwise_affine=True, weight_shape=None):
+        super().__init__()
+        self.dim = dim
+        self.eps = eps
+        self.elementwise_affine = elementwise_affine
+        if self.elementwise_affine:
+            weight_shape = (dim,) if weight_shape is None else weight_shape
+            self.weight = nn.Parameter(torch.ones(weight_shape))
+        else:
+            self.register_parameter('weight', None)
+
+    def _norm(self, x):
+        return x * torch.rsqrt(x.pow(2).mean(-1, keepdim=True) + self.eps)
+
+    def forward(self, x):
+        output = self._norm(x.float()).type_as(x)
+        if self.weight is not None:
+            output = output * self.weight
+        return output
+
+    def extra_repr(self) -> str:
+        return f'dim={self.dim}, eps={self.eps}, elementwise_affine={self.elementwise_affine}'
+
+class ConvRMSNorm(RMSNorm):
+    def __init__(self, dim: int, eps: float = 1e-5, elementwise_affine=True, weight_shape=None):
+        super().__init__(dim, eps, elementwise_affine, weight_shape)
+
+    def forward(self, x):
+        x = x.transpose(1, 2)  # b ... t -> b t ...
+        if (not APEX_AVAILABLE) or (not self.elementwise_affine):
+            # Fallback to native implementation
+            output = self._norm(x.float()).type_as(x)
+            if self.weight is not None:
+                output = output * self.weight
+        else:
+            output = fused_rms_norm_affine(x, self.weight, self.weight.shape, self.eps)
+        output = output.transpose(1, 2)  # b t ... -> b ... t
+        return output
+
+# Convolutional layers and utilities
+CONV_NORMALIZATIONS = frozenset(['none', 'weight_norm', 'spectral_norm',
+                                'time_layer_norm', 'layer_norm', 'time_group_norm'])
+
+
+def apply_parametrization_norm(module: nn.Module, norm: str = 'none') -> nn.Module:
+    assert norm in CONV_NORMALIZATIONS
+    if norm == 'weight_norm':
+        return nn.utils.weight_norm(module)
+    elif norm == 'spectral_norm':
+        return nn.utils.spectral_norm(module)
+    else:
+        # We already check was in CONV_NORMALIZATION, so any other choice
+        # doesn't need reparametrization.
+        return module
+
+
+def get_norm_module(module: nn.Module, causal: bool = False, norm: str = 'none', **norm_kwargs) -> nn.Module:
+    """Return the proper normalization module. If causal is True, this will ensure the returned
+    module is causal, or return an error if the normalization doesn't support causal evaluation.
+    """
+    assert norm in CONV_NORMALIZATIONS
+    if norm == 'layer_norm':
+        assert isinstance(module, nn.modules.conv._ConvNd)
+        return ConvLayerNorm(module.out_channels, **norm_kwargs)
+    elif norm == 'time_group_norm':
+        if causal:
+            raise ValueError("GroupNorm doesn't support causal evaluation.")
+        assert isinstance(module, nn.modules.conv._ConvNd)
+        return nn.GroupNorm(1, module.out_channels, **norm_kwargs)
+    else:
+        return nn.Identity()
+
+
+def get_extra_padding_for_conv1d(x: torch.Tensor, kernel_size: int, stride: int,
+                                padding_total: int = 0) -> int:
+    """Calculate extra padding needed for convolution to have the same output length"""
+    length = x.shape[-1]
+    n_frames = (length - kernel_size + padding_total) / stride + 1
+    ideal_length = (math.ceil(n_frames) - 1) * stride + (kernel_size - padding_total)
+    return ideal_length - length
+
+
+def pad1d(x: torch.Tensor, paddings: tp.Tuple[int, int], mode: str = 'zero', value: float = 0.):
+    """Pad 1D input with handling for small inputs in reflect mode"""
+    length = x.shape[-1]
+    padding_left, padding_right = paddings
+    assert padding_left >= 0 and padding_right >= 0, (padding_left, padding_right)
+    if mode == 'reflect':
+        max_pad = max(padding_left, padding_right)
+        extra_pad = 0
+        if length <= max_pad:
+            extra_pad = max_pad - length + 1
+            x = F.pad(x, (0, extra_pad))
+        padded = F.pad(x, paddings, mode, value)
+        end = padded.shape[-1] - extra_pad
+        return padded[..., :end]
+    else:
+        return F.pad(x, paddings, mode, value)
+
+
+def unpad1d(x: torch.Tensor, paddings: tp.Tuple[int, int]):
+    """Remove padding from x, handling properly zero padding. Only for 1d!"""
+    padding_left, padding_right = paddings
+    assert padding_left >= 0 and padding_right >= 0, (padding_left, padding_right)
+    assert (padding_left + padding_right) <= x.shape[-1]
+    end = x.shape[-1] - padding_right
+    return x[..., padding_left: end]
+
+
+class NormConv1d(nn.Module):
+    """Wrapper around Conv1d and normalization applied to this conv"""
+    def __init__(self, *args, causal: bool = False, norm: str = 'none',
+                norm_kwargs: tp.Dict[str, tp.Any] = {}, **kwargs):
+        super().__init__()
+        self.conv = apply_parametrization_norm(nn.Conv1d(*args, **kwargs), norm)
+        self.norm = get_norm_module(self.conv, causal, norm, **norm_kwargs)
+        self.norm_type = norm
+
+    def forward(self, x):
+        x = self.conv(x)
+        x = self.norm(x)
+        return x
+
+
+class NormConvTranspose1d(nn.Module):
+    """Wrapper around ConvTranspose1d and normalization applied to this conv"""
+    def __init__(self, *args, causal: bool = False, norm: str = 'none',
+                norm_kwargs: tp.Dict[str, tp.Any] = {}, **kwargs):
+        super().__init__()
+        self.convtr = apply_parametrization_norm(nn.ConvTranspose1d(*args, **kwargs), norm)
+        self.norm = get_norm_module(self.convtr, causal, norm, **norm_kwargs)
+        self.norm_type = norm
+
+    def forward(self, x):
+        x = self.convtr(x)
+        x = self.norm(x)
+        return x
+
+
+class VibeVoiceTokenizerStreamingCache:
+    """Cache for streaming convolution, similar to KV cache in attention"""
+    def __init__(self):
+        self.cache = {}  # Dict mapping (layer_id, sample_idx) to state tensor
+        
+    def get(self, layer_id: str, sample_indices: torch.Tensor) -> Optional[torch.Tensor]:
+        """Get cached states for given layer and sample indices"""
+        states = []
+        max_length = 0
+        
+        # First pass: collect states and find max length
+        for idx in sample_indices.tolist():
+            key = (layer_id, idx)
+            if key not in self.cache:
+                return None  # If any sample is missing, return None
+            state = self.cache[key]
+            states.append(state)
+            max_length = max(max_length, state.shape[-1])
+        
+        # Second pass: pad states to max length if needed
+        if len(states) > 0 and states[0].dim() >= 2:
+            padded_states = []
+            for state in states:
+                if state.shape[-1] < max_length:
+                    # Pad on the time dimension (last dimension)
+                    pad_size = max_length - state.shape[-1]
+                    # Pad with zeros on the LEFT to align the most recent samples
+                    padded_state = F.pad(state, (pad_size, 0), mode='constant', value=0)
+                    padded_states.append(padded_state)
+                else:
+                    padded_states.append(state)
+            return torch.stack(padded_states, dim=0)
+        else:
+            return torch.stack(states, dim=0)
+    
+    def set(self, layer_id: str, sample_indices: torch.Tensor, states: torch.Tensor):
+        """Set cached states for given layer and sample indices"""
+        for i, idx in enumerate(sample_indices.tolist()):
+            key = (layer_id, idx)
+            self.cache[key] = states[i].detach()
+
+    def set_to_zero(self, sample_indices: torch.Tensor):
+        """Set all cached states to zero for given sample indices"""
+        for key in list(self.cache.keys()):
+            layer_id, sample_idx = key
+            if sample_idx in sample_indices.tolist():
+                # Create zero tensor with same shape and dtype as cached tensor
+                cached_tensor = self.cache[key]
+                self.cache[key] = torch.zeros_like(cached_tensor)
+                
+    def clear(self, layer_id: Optional[str] = None, sample_indices: Optional[torch.Tensor] = None):
+        """Clear cache for specific layer/samples or everything"""
+        if layer_id is None and sample_indices is None:
+            self.cache.clear()
+        elif layer_id is not None and sample_indices is None:
+            # Clear all samples for a specific layer
+            keys_to_remove = [k for k in self.cache.keys() if k[0] == layer_id]
+            for k in keys_to_remove:
+                del self.cache[k]
+        elif layer_id is not None and sample_indices is not None:
+            # Clear specific samples for a specific layer
+            for idx in sample_indices.tolist():
+                key = (layer_id, idx)
+                self.cache.pop(key, None)
+
+class SConv1d(nn.Module):
+    """Conv1d with built-in handling of asymmetric or causal padding and normalization."""
+    def __init__(self, in_channels: int, out_channels: int,
+                kernel_size: int, stride: int = 1, dilation: int = 1,
+                groups: int = 1, bias: bool = True, causal: bool = False,
+                norm: str = 'none', norm_kwargs: tp.Dict[str, tp.Any] = {},
+                pad_mode: str = 'reflect'):
+        super().__init__()
+        self.conv = NormConv1d(in_channels, out_channels, kernel_size, stride,
+                            dilation=dilation, groups=groups, bias=bias, causal=causal,
+                            norm=norm, norm_kwargs=norm_kwargs)
+        self.causal = causal
+        self.pad_mode = pad_mode
+        
+        # Store configuration
+        self.kernel_size = kernel_size
+        self.dilation = dilation
+        self.stride = stride
+        self.in_channels = in_channels
+        self.out_channels = out_channels
+        
+        # For causal convolution, we need to maintain kernel_size - 1 samples as context
+        # need to check use which context_size is more suitable
+        # self.context_size = (kernel_size - 1) * dilation
+        self.context_size = (kernel_size - 1) * dilation - (stride - 1)
+        
+        # For non-streaming mode, calculate padding
+        self.padding_total = (kernel_size - 1) * dilation - (stride - 1)
+        
+        # Create a unique layer ID for cache management
+        self._layer_id = None
+                  
+    @property
+    def layer_id(self):
+        if self._layer_id is None:
+            self._layer_id = f"sconv1d_{id(self)}"
+        return self._layer_id
+        
+    def forward(self, x: torch.Tensor, 
+                cache: Optional[VibeVoiceTokenizerStreamingCache] = None,
+                sample_indices: Optional[torch.Tensor] = None,
+                use_cache: bool = False,
+                debug: bool = False) -> torch.Tensor:
+        """
+        Forward pass with optional streaming support via cache.
+        
+        Args:
+            x: Input tensor [batch_size, channels, time]
+            cache: VibeVoiceTokenizerStreamingCache object for maintaining states
+            sample_indices: Indices identifying each sample for cache management
+            use_cache: Whether to use cached states for streaming
+            debug: Whether to print debug information
+            
+        Returns:
+            Output tensor
+        """
+        B, C, T = x.shape
+        
+        # Non-streaming mode
+        if not use_cache or cache is None:
+            return self._forward_non_streaming(x, debug=debug)
+        
+        # Streaming mode
+        assert self.causal, "Streaming mode is only supported for causal convolutions"
+        assert sample_indices is not None, "sample_indices must be provided for streaming mode"
+        assert len(sample_indices) == B, "sample_indices must match batch size"
+        
+        return self._forward_streaming(x, cache, sample_indices, debug)
+    
+    def _forward_streaming(self, x: torch.Tensor, 
+                          cache: VibeVoiceTokenizerStreamingCache,
+                          sample_indices: torch.Tensor,
+                          debug: bool = False) -> torch.Tensor:
+        """Streaming forward pass with cache operations kept separate from compiled code"""
+        B, C, T = x.shape
+        
+        # Cache operations (not compiled)
+        cached_states = cache.get(self.layer_id, sample_indices)
+        
+        if cached_states is None:
+            # First chunk - initialize with zeros for context
+            if self.context_size > 0:
+                cached_states = torch.zeros(B, C, self.context_size, device=x.device, dtype=x.dtype)
+                if debug:
+                    print(f"[DEBUG] Initialized cache with shape: {cached_states.shape}, context_size={self.context_size}")
+            else:
+                cached_states = torch.zeros(B, C, 0, device=x.device, dtype=x.dtype)
+                if debug:
+                    print(f"[DEBUG] No context needed (kernel_size=stride)")
+        
+        # Concatenate cached states with input
+        if cached_states.shape[2] > 0:
+            input_with_context = torch.cat([cached_states, x], dim=2)
+        else:
+            input_with_context = x
+            
+        if debug:
+            print(f"[DEBUG] Input shape: {x.shape}, Cache shape: {cached_states.shape}, Combined: {input_with_context.shape}")
+        
+        # Apply convolution directly - no extra padding in streaming mode
+        # The conv layer will handle its own padding internally
+        output = self.conv(input_with_context)
+
+        if debug:
+            print(f"[DEBUG] Output shape: {output.shape}")
+        
+        # Update cache for next chunk
+        if self.context_size > 0:
+            # Calculate how many samples to keep
+            total_input_length = input_with_context.shape[2]
+            
+            # Keep the last context_size samples
+            if total_input_length >= self.context_size:
+                new_cache_start = total_input_length - self.context_size
+                new_cache = input_with_context[:, :, new_cache_start:]
+            else:
+                # If we have less than context_size samples, keep everything
+                new_cache = input_with_context
+                
+            if debug:
+                print(f"[DEBUG] New cache shape: {new_cache.shape}")
+                
+            cache.set(self.layer_id, sample_indices, new_cache)
+        
+        return output
+    
+    def _forward_non_streaming(self, x: torch.Tensor, debug: bool = False) -> torch.Tensor:
+        """Standard forward pass without streaming"""
+        B, C, T = x.shape
+        kernel_size = self.kernel_size
+        stride = self.stride
+        dilation = self.dilation
+        padding_total = self.padding_total
+        
+        # Compute extra padding for stride alignment
+        extra_padding = get_extra_padding_for_conv1d(x, kernel_size, stride, padding_total)
+        
+        if debug:
+            print(f"[DEBUG NON-STREAMING] Input shape: {x.shape}, padding_total={padding_total}, extra_padding={extra_padding}")
+        
+        if self.causal:
+            # Left padding for causal
+            if self.pad_mode == 'constant':
+                x = pad1d(x, (padding_total, extra_padding), mode=self.pad_mode, value=0)
+            else:
+                x = pad1d(x, (padding_total, extra_padding), mode=self.pad_mode)
+        else:
+            # Symmetric padding for non-causal
+            padding_right = padding_total // 2
+            padding_left = padding_total - padding_right
+            x = pad1d(x, (padding_left, padding_right + extra_padding), mode=self.pad_mode)
+        
+        if debug:
+            print(f"[DEBUG NON-STREAMING] After padding: {x.shape}")
+            
+        output = self.conv(x)
+        
+        if debug:
+            print(f"[DEBUG NON-STREAMING] Output shape: {output.shape}")
+        
+        return output
+
+
+class SConvTranspose1d(nn.Module):
+    """ConvTranspose1d with built-in handling of asymmetric or causal padding and normalization."""
+    def __init__(self, in_channels: int, out_channels: int,
+                kernel_size: int, stride: int = 1, causal: bool = False,
+                norm: str = 'none', trim_right_ratio: float = 1.,
+                norm_kwargs: tp.Dict[str, tp.Any] = {}, bias: bool = True):
+        super().__init__()
+        self.convtr = NormConvTranspose1d(in_channels, out_channels, kernel_size, stride,
+                                        causal=causal, norm=norm, norm_kwargs=norm_kwargs, bias=bias)
+        self.causal = causal
+        self.trim_right_ratio = trim_right_ratio
+        assert self.causal or self.trim_right_ratio == 1., \
+            "`trim_right_ratio` != 1.0 only makes sense for causal convolutions"
+        assert self.trim_right_ratio >= 0. and self.trim_right_ratio <= 1.
+
+        # Store configuration
+        self.kernel_size = kernel_size
+        self.stride = stride
+        self.in_channels = in_channels
+        self.out_channels = out_channels
+        
+        # For transposed convolution, padding calculation is different
+        self.padding_total = kernel_size - stride
+        
+        # For streaming, we need to keep track of input history
+        # Transposed conv needs to see multiple input samples to produce correct output
+        self.context_size = kernel_size - 1
+        
+        # Create a unique layer ID for cache management
+        self._layer_id = None
+
+    @property
+    def layer_id(self):
+        if self._layer_id is None:
+            self._layer_id = f"sconvtr1d_{id(self)}"
+        return self._layer_id
+    
+    def forward(self, x: torch.Tensor,
+                cache: Optional[VibeVoiceTokenizerStreamingCache] = None,
+                sample_indices: Optional[torch.Tensor] = None,
+                use_cache: bool = False,
+                debug: bool = False) -> torch.Tensor:
+        """
+        Forward pass with optional streaming support via cache.
+        """
+        B, C, T = x.shape
+        
+        # Non-streaming mode
+        if not use_cache or cache is None:
+            return self._forward_non_streaming(x, debug=debug)
+        
+        # Streaming mode
+        assert sample_indices is not None, "sample_indices must be provided for streaming mode"
+        assert len(sample_indices) == B, "sample_indices must match batch size"
+        
+        return self._forward_streaming(x, cache, sample_indices, debug)
+    
+    def _forward_streaming(self, x: torch.Tensor,
+                          cache: VibeVoiceTokenizerStreamingCache,
+                          sample_indices: torch.Tensor,
+                          debug: bool = False) -> torch.Tensor:
+        """Streaming forward pass with cache operations kept separate from compiled code"""
+        B, C, T = x.shape
+        
+        # Cache operations (not compiled)
+        cached_input = cache.get(self.layer_id, sample_indices)
+        
+        if cached_input is None:
+            # First chunk - no history yet
+            cached_input = torch.zeros(B, C, 0, device=x.device, dtype=x.dtype)
+            if debug:
+                print(f"[DEBUG] Initialized empty cache for transposed conv")
+        
+        # Concatenate cached input with new input
+        full_input = torch.cat([cached_input, x], dim=2)
+        
+        if debug:
+            print(f"[DEBUG] Input shape: {x.shape}, Cache shape: {cached_input.shape}, Combined: {full_input.shape}")
+        
+        # First chunk or debug mode - use uncompiled version
+        full_output = self.convtr(full_input)
+        
+        if debug:
+            print(f"[DEBUG] Full transposed conv output shape: {full_output.shape}")
+        
+        # Calculate padding to remove
+        if self.causal:
+            padding_right = math.ceil(self.padding_total * self.trim_right_ratio)
+            padding_left = self.padding_total - padding_right
+        else:
+            padding_right = self.padding_total // 2
+            padding_left = self.padding_total - padding_right
+        
+        # Remove padding
+        if padding_left + padding_right > 0:
+            full_output = unpad1d(full_output, (padding_left, padding_right))
+        
+        if debug:
+            print(f"[DEBUG] After unpadding: {full_output.shape}")
+        
+        # Determine which part of the output corresponds to the new input
+        if cached_input.shape[2] == 0:
+            # First chunk - return all output
+            output = full_output
+        else:
+            # Subsequent chunks - return only the new output
+            expected_new_output = T * self.stride
+            
+            # Take the last expected_new_output samples
+            if full_output.shape[2] >= expected_new_output:
+                output = full_output[:, :, -expected_new_output:]
+            else:
+                output = full_output
+        
+        if debug:
+            print(f"[DEBUG] Final streaming output shape: {output.shape}")
+        
+        # Update cache
+        if full_input.shape[2] > self.context_size:
+            new_cache = full_input[:, :, -self.context_size:]
+        else:
+            new_cache = full_input
+        
+        if debug:
+            print(f"[DEBUG] New cache shape: {new_cache.shape}")
+            
+        cache.set(self.layer_id, sample_indices, new_cache)
+        
+        return output
+    
+    def _forward_non_streaming(self, x: torch.Tensor, debug: bool = False) -> torch.Tensor:
+        """Standard forward pass without streaming"""
+        if debug:
+            print(f"[DEBUG NON-STREAMING] Input shape: {x.shape}")
+        
+        # Apply transposed convolution
+        y = self.convtr(x)
+        
+        if debug:
+            print(f"[DEBUG NON-STREAMING] After transposed conv: {y.shape}")
+        
+        # Calculate and remove padding
+        if self.causal:
+            padding_right = math.ceil(self.padding_total * self.trim_right_ratio)
+            padding_left = self.padding_total - padding_right
+        else:
+            padding_right = self.padding_total // 2
+            padding_left = self.padding_total - padding_right
+        
+        if padding_left + padding_right > 0:
+            y = unpad1d(y, (padding_left, padding_right))
+        
+        if debug:
+            print(f"[DEBUG NON-STREAMING] Final output shape: {y.shape}")
+            
+        return y
+    
+# FFN 
+class FFN(nn.Module):
+    def __init__(
+        self,
+        embed_dim,
+        ffn_dim,
+        bias=False,
+    ):
+        super().__init__()
+        self.embed_dim = embed_dim
+        self.linear1 = nn.Linear(self.embed_dim, ffn_dim, bias=bias) 
+        self.gelu = ACT2FN["gelu"]
+        self.linear2 = nn.Linear(ffn_dim, self.embed_dim, bias=bias)
+
+    def forward(self, x):
+        x = self.linear1(x)
+        x = self.gelu(x)
+        x = self.linear2(x)
+        return x
+
+
+class Convlayer(nn.Module):
+    def __init__(
+            self, 
+            in_channels, 
+            out_channels, 
+            kernel_size, 
+            stride=1, 
+            dilation=1, 
+            groups=1, 
+            bias=True, 
+            pad_mode='zeros', 
+            norm='weight_norm', 
+            causal=True, 
+        ):
+        super().__init__()
+        self.conv = SConv1d(in_channels, out_channels, kernel_size, stride=stride, dilation=dilation, 
+                           groups=groups, bias=bias, pad_mode=pad_mode, norm=norm, causal=causal)
+
+    def forward(self, x):
+        return self.conv(x)
+
+class Block1D(nn.Module):
+    def __init__(self, dim, kernel_size=7, drop_path=0., mixer_layer='conv',  
+                layer_scale_init_value=1e-6, **kwargs):
+        super().__init__()
+        
+        if kwargs.get('layernorm', 'LN') == 'LN':
+            self.norm = ConvLayerNorm(dim, eps=kwargs.get('eps', 1e-6))
+            self.ffn_norm = ConvLayerNorm(dim, eps=kwargs.get('eps', 1e-6))               
+        elif kwargs.get('layernorm', 'RMSNorm') == 'RMSNorm':
+            self.norm = ConvRMSNorm(dim, eps=kwargs.get('eps', 1e-6))
+            self.ffn_norm = ConvRMSNorm(dim, eps=kwargs.get('eps', 1e-6))
+
+        if mixer_layer == 'conv':
+            self.mixer = Convlayer(dim, dim, groups=kwargs.get('groups', 1),
+                                kernel_size=kernel_size, 
+                                pad_mode=kwargs.get('pad_mode', 'reflect'), 
+                                norm=kwargs.get('norm', 'none'), 
+                                causal=kwargs.get('causal', True), 
+                                bias=kwargs.get('bias', True),
+                                )
+        elif mixer_layer == 'depthwise_conv':
+            self.mixer = Convlayer(dim, dim, groups=dim,
+                                kernel_size=kernel_size, 
+                                pad_mode=kwargs.get('pad_mode', 'reflect'), 
+                                norm=kwargs.get('norm', 'none'), 
+                                causal=kwargs.get('causal', True), 
+                                bias=kwargs.get('bias', True),
+                                )
+        else:
+            raise ValueError(f"Unsupported mixer layer: {mixer_layer}")
+        
+        self.ffn = FFN(
+            dim, 
+            kwargs.get('ffn_expansion', 4) * dim, 
+            bias=kwargs.get('bias', False),
+        )
+        self.drop_path = nn.Identity() if drop_path <= 0. else nn.modules.DropPath(drop_path)
+
+        if layer_scale_init_value > 0:
+            self.gamma = nn.Parameter(layer_scale_init_value * torch.ones((dim)), requires_grad=True)
+            self.ffn_gamma = nn.Parameter(layer_scale_init_value * torch.ones((dim)), requires_grad=True)
+        else:
+            self.gamma = None
+            self.ffn_gamma = None
+
+    def forward(self, x):
+        # mixer
+        residual = x
+        x = self.norm(x)
+        x = self.mixer(x)
+        if self.gamma is not None:
+            x = x * self.gamma.unsqueeze(-1)
+        x = residual + self.drop_path(x)
+
+        # ffn
+        residual = x
+        x = self.ffn_norm(x)
+        x = x.permute(0, 2, 1)
+        x = self.ffn(x)
+        x = x.permute(0, 2, 1)
+        if self.ffn_gamma is not None:
+            x = x * self.ffn_gamma.unsqueeze(-1)
+        x = residual + self.drop_path(x)
+
+        return x
+
+
+class TokenizerEncoder(nn.Module):
+    """
+    Encoder component for the VibeVoice tokenizer that converts audio to latent representations.
+    
+    Args:
+        config: Configuration object with model parameters
+    """
+    def __init__(self, config):
+        super().__init__()
+        
+        # Extract parameters from config
+        self.channels = config.channels
+        self.dimension = config.dimension
+        self.n_filters = config.n_filters
+        self.ratios = list(reversed(config.ratios))
+        self.depths = config.depths
+        self.n_residual_layers = getattr(config, "n_residual_layers", 1)
+        self.hop_length = np.prod(self.ratios)
+        self.causal = config.causal
+        
+        # Additional config parameters with defaults
+        kernel_size = getattr(config, "kernel_size", 7)
+        last_kernel_size = getattr(config, "last_kernel_size", 7)
+        norm = getattr(config, "norm", "none")
+        norm_params = getattr(config, "norm_params", {})
+        pad_mode = getattr(config, "pad_mode", "reflect")
+        bias = getattr(config, "bias", True)
+        layernorm = getattr(config, "layernorm", "LN")
+        layernorm_eps = getattr(config, "layernorm_eps", 1e-6)
+        layernorm_elementwise_affine = getattr(config, "layernorm_elementwise_affine", True)
+        drop_path_rate = getattr(config, "drop_path_rate", 0.0)
+        mixer_layer = getattr(config, "mixer_layer", "conv")
+        layer_scale_init_value = getattr(config, "layer_scale_init_value", 0)
+        disable_last_norm = getattr(config, "disable_last_norm", False)
+        
+        # determine the norm type based on layernorm
+        if layernorm == 'LN':
+            norm_type = ConvLayerNorm
+        elif layernorm == 'RMSNorm':
+            norm_type = partial(ConvRMSNorm, elementwise_affine=layernorm_elementwise_affine)
+        else:
+            raise ValueError(f"Unsupported norm type: {layernorm}")
+        
+        # stem and intermediate downsampling conv layers
+        stem = nn.Sequential(
+                SConv1d(self.channels, self.n_filters, kernel_size, norm=norm, norm_kwargs=norm_params, causal=self.causal, pad_mode=pad_mode, bias=bias),
+            )
+        
+        self.downsample_layers = nn.ModuleList()
+        self.downsample_layers.append(stem)
+        for i in range(len(self.ratios)):
+            in_ch = self.n_filters * (2 ** i)
+            out_ch = self.n_filters * (2 ** (i + 1))
+            downsample_layer = nn.Sequential(
+                SConv1d(in_ch, out_ch, kernel_size=self.ratios[i] * 2, stride=self.ratios[i], causal=self.causal, pad_mode=pad_mode, norm=norm, bias=bias)
+            )
+            self.downsample_layers.append(downsample_layer)
+
+        # configure the transformer blocks
+        layer_type = partial(
+            Block1D,
+            mixer_layer=mixer_layer,
+            layernorm=layernorm,
+            eps=layernorm_eps,
+            causal=self.causal,
+            pad_mode=pad_mode,
+            norm=norm,
+            bias=bias,
+            layer_scale_init_value=layer_scale_init_value,
+        )
+        
+        self.stages = nn.ModuleList()
+        dp_rates = list(np.linspace(0, drop_path_rate, sum(self.depths)).tolist())
+        cur = 0
+
+        for i in range(len(self.depths)):
+            in_ch = self.n_filters * (2 ** i)
+            stage = nn.Sequential(
+                *[layer_type(dim=in_ch, drop_path=dp_rates[cur + j]) for j in range(self.depths[i])]
+            )
+            self.stages.append(stage)
+            cur += self.depths[i]
+        
+        if not disable_last_norm:
+            self.norm = norm_type(in_ch, eps=layernorm_eps)
+        else:
+            self.norm = nn.Identity()
+        self.head = SConv1d(in_ch, self.dimension, kernel_size=last_kernel_size, causal=self.causal, pad_mode=pad_mode, norm=norm, bias=bias)
+
+    def forward_features(self, x, cache=None, sample_indices=None, use_cache=False, debug=False):
+        for i in range(len(self.depths)):
+            # Apply downsampling
+            for layer in self.downsample_layers[i]:
+                if isinstance(layer, SConv1d):
+                    x = layer(x, cache=cache, sample_indices=sample_indices, use_cache=use_cache, debug=debug)
+                else:
+                    x = layer(x)
+            
+            # Apply stage (Block1D contains Convlayer which contains SConv1d)
+            for block in self.stages[i]:
+                if hasattr(block, 'mixer') and hasattr(block.mixer, 'conv') and isinstance(block.mixer.conv, SConv1d):
+                    # Block1D forward with cache support
+                    residual = x
+                    x = block.norm(x)
+                    x = block.mixer.conv(x, cache=cache, sample_indices=sample_indices, use_cache=use_cache, debug=debug)
+                    if block.gamma is not None:
+                        x = x * block.gamma.unsqueeze(-1)
+                    x = residual + x
+                    
+                    # FFN part
+                    residual = x
+                    x = block.ffn_norm(x)
+                    x = x.permute(0, 2, 1)
+                    x = block.ffn(x)
+                    x = x.permute(0, 2, 1)
+                    if block.ffn_gamma is not None:
+                        x = x * block.ffn_gamma.unsqueeze(-1)
+                    x = residual + x
+                else:
+                    x = block(x)
+
+        return self.norm(x)
+
+    def forward(self, x, cache=None, sample_indices=None, use_cache=False, debug=False):
+        x = self.forward_features(x, cache=cache, sample_indices=sample_indices, use_cache=use_cache, debug=debug)
+        x = self.head(x, cache=cache, sample_indices=sample_indices, use_cache=use_cache, debug=debug)
+        return x
+
+
+class TokenizerDecoder(nn.Module):
+    """
+    Decoder component for the VibeVoice tokenizer that converts latent representations back to audio.
+    
+    Args:
+        config: Configuration object with model parameters
+    """
+    def __init__(self, config):
+        super().__init__()
+        
+        # Extract parameters from config
+        self.dimension = config.dimension
+        self.channels = config.channels
+        self.n_filters = config.n_filters
+        self.ratios = config.ratios
+        
+        # IMPORTANT CHANGE: Don't reverse depths again since they're already reversed in VibeVoiceAcousticTokenizerModel
+        self.depths = config.depths  # Changed from list(reversed(config.depths))
+        
+        self.n_residual_layers = getattr(config, "n_residual_layers", 1)
+        self.hop_length = np.prod(self.ratios)
+        self.causal = config.causal
+        
+        # Additional config parameters with defaults
+        kernel_size = getattr(config, "kernel_size", 7)
+        last_kernel_size = getattr(config, "last_kernel_size", 7)
+        norm = getattr(config, "norm", "none")
+        norm_params = getattr(config, "norm_params", {})
+        pad_mode = getattr(config, "pad_mode", "reflect")
+        bias = getattr(config, "bias", True)
+        layernorm = getattr(config, "layernorm", "LN")
+        layernorm_eps = getattr(config, "layernorm_eps", 1e-6)
+        trim_right_ratio = getattr(config, "trim_right_ratio", 1.0)
+        layernorm_elementwise_affine = getattr(config, "layernorm_elementwise_affine", True)
+        drop_path_rate = getattr(config, "drop_path_rate", 0.0)
+        mixer_layer = getattr(config, "mixer_layer", "conv")
+        layer_scale_init_value = getattr(config, "layer_scale_init_value", 0)
+        disable_last_norm = getattr(config, "disable_last_norm", False)
+
+        # determine the norm type based on layernorm
+        if layernorm == 'LN':
+            norm_type = ConvLayerNorm
+        elif layernorm == 'RMSNorm':
+            norm_type = partial(ConvRMSNorm, elementwise_affine=layernorm_elementwise_affine)
+        else:
+            raise ValueError(f"Unsupported norm type: {layernorm}")
+        
+        # stem and upsampling layers
+        stem = nn.Sequential(
+                SConv1d(self.dimension, self.n_filters * 2 ** (len(self.depths) - 1), kernel_size, norm=norm, 
+                        norm_kwargs=norm_params, causal=self.causal, pad_mode=pad_mode, bias=bias),
+            )
+        
+        self.upsample_layers = nn.ModuleList()
+        self.upsample_layers.append(stem)
+        for i in range(len(self.ratios)):
+            in_ch = self.n_filters * (2 ** (len(self.depths) - 1 - i))
+            out_ch = self.n_filters * (2 ** (len(self.depths) - 1 - i - 1))
+            upsample_layer = nn.Sequential(
+                SConvTranspose1d(in_ch, out_ch,
+                                kernel_size=self.ratios[i] * 2, stride=self.ratios[i],
+                                norm=norm, norm_kwargs=norm_params, bias=bias,
+                                causal=self.causal, trim_right_ratio=trim_right_ratio),
+            )
+            self.upsample_layers.append(upsample_layer)
+
+        # configure transformer blocks
+        layer_type = partial(
+            Block1D,
+            mixer_layer=mixer_layer,
+            layernorm=layernorm,
+            eps=layernorm_eps,
+            causal=self.causal,
+            pad_mode=pad_mode,
+            norm=norm,
+            bias=bias,
+            layer_scale_init_value=layer_scale_init_value,
+        )
+
+        self.stages = nn.ModuleList()
+        dp_rates = list(np.linspace(0, drop_path_rate, sum(self.depths)).tolist())
+        cur = 0
+        
+        # Create stages in the same order as the original model
+        for i in range(len(self.depths)):
+            in_ch = self.n_filters * (2 ** (len(self.depths) - 1 - i))
+            stage = nn.Sequential(
+                *[layer_type(dim=in_ch, drop_path=dp_rates[cur + j]) for j in range(self.depths[i])]
+            )
+            self.stages.append(stage)
+            cur += self.depths[i]
+
+        if not disable_last_norm:
+            self.norm = norm_type(in_ch, eps=layernorm_eps)
+        else:
+            self.norm = nn.Identity()
+        self.head = SConv1d(in_ch, self.channels, kernel_size=last_kernel_size, causal=self.causal, pad_mode=pad_mode, norm=norm, bias=bias)
+
+    def forward_features(self, x, cache=None, sample_indices=None, use_cache=False, debug=False):
+        for i in range(len(self.depths)):
+            # Apply upsampling
+            for layer in self.upsample_layers[i]:
+                if isinstance(layer, (SConv1d, SConvTranspose1d)):
+                    x = layer(x, cache=cache, sample_indices=sample_indices, use_cache=use_cache, debug=debug)
+                else:
+                    x = layer(x)
+            
+            # Apply stage (Block1D contains Convlayer which contains SConv1d)
+            for block in self.stages[i]:
+                if hasattr(block, 'mixer') and hasattr(block.mixer, 'conv') and isinstance(block.mixer.conv, SConv1d):
+                    # Block1D forward with cache support
+                    residual = x
+                    x = block.norm(x)
+                    x = block.mixer.conv(x, cache=cache, sample_indices=sample_indices, use_cache=use_cache, debug=debug)
+                    if block.gamma is not None:
+                        x = x * block.gamma.unsqueeze(-1)
+                    x = residual + x
+                    
+                    # FFN part
+                    residual = x
+                    x = block.ffn_norm(x)
+                    x = x.permute(0, 2, 1)
+                    x = block.ffn(x)
+                    x = x.permute(0, 2, 1)
+                    if block.ffn_gamma is not None:
+                        x = x * block.ffn_gamma.unsqueeze(-1)
+                    x = residual + x
+                else:
+                    x = block(x)
+
+        return self.norm(x)
+    
+    def forward(self, x, cache=None, sample_indices=None, use_cache=False, debug=False):
+        x = self.forward_features(x, cache=cache, sample_indices=sample_indices, use_cache=use_cache, debug=debug)
+        x = self.head(x, cache=cache, sample_indices=sample_indices, use_cache=use_cache, debug=debug)
+        return x
+    
+
+@dataclass
+class VibeVoiceTokenizerEncoderOutput:
+    """
+    Output of VibeVoice tokenizer encoder, representing a Gaussian distribution with fixed variance.
+    
+    Args:
+        mean (`torch.FloatTensor`): The mean parameters of the distribution.
+        std (`float` or `torch.FloatTensor`): Fixed standard deviation value.
+    """
+    mean: torch.Tensor
+    std: Optional[Union[float, torch.Tensor]] = None
+    
+    def sample(self, dist_type='fix'):
+        """
+        Sample from the distribution.
+        
+        Args:
+            dist_type (`str`): Sampling method, either 'fix' or 'gaussian'.
+                
+        Returns:
+            `torch.FloatTensor`: Sampled values.
+            `torch.FloatTensor` (optional): Standard deviation used (only when dist_type='gaussian').
+        """
+        if dist_type == 'fix':
+            x = self.mean + self.std * torch.randn_like(self.mean)
+            return x, self.std
+        elif dist_type == 'gaussian':
+            batch_size = self.mean.size(0)
+            value = self.std / 0.8
+            std = torch.randn(batch_size, device=self.mean.device, dtype=self.mean.dtype) * value
+
+            while std.dim() < self.mean.dim():
+                std = std.unsqueeze(-1)
+
+            x = self.mean + std * torch.randn_like(self.mean)
+            return x, std
+        else:
+            return self.mean, self.std
+
+    def kl(self):
+        """Compute KL divergence between this distribution and a standard normal."""
+        target = torch.zeros_like(self.mean)
+        return F.mse_loss(self.mean, target, reduction='none')
+
+    def mode(self):
+        """Return the distribution mode (which is the mean for Gaussian)."""
+        return self.mean
+    
+class VibeVoiceAcousticTokenizerModel(PreTrainedModel):
+    """VibeVoice speech tokenizer model combining encoder and decoder for acoustic tokens"""
+    
+    config_class = VibeVoiceAcousticTokenizerConfig
+    base_model_prefix = "vibevoice_acoustic_tokenizer"
+    _supports_flash_attn_2 = True  
+    _supports_sdpa = True  
+    _no_split_modules = ["TokenizerEncoder", "TokenizerDecoder"]
+
+    def __init__(self, config):
+        super().__init__(config)
+        
+        self.register_buffer('fix_std', torch.tensor(config.fix_std), persistent=False)
+        self.std_dist_type = getattr(config, "std_dist_type", "fix")
+        
+        # Parse encoder depths
+        if isinstance(config.encoder_depths, str):
+            encoder_depths = [int(d) for d in config.encoder_depths.split('-')]
+        else:
+            encoder_depths = config.encoder_depths
+            
+        # Parse decoder depths if provided
+        if config.decoder_depths is not None and isinstance(config.decoder_depths, str):
+            decoder_depths = [int(d) for d in config.decoder_depths.split('-')]
+        else:
+            # Default: use reversed encoder depths if decoder_depths is None
+            decoder_depths = list(reversed(encoder_depths))
+        
+        # Create encoder config
+        encoder_config = copy.deepcopy(config)
+        encoder_config.dimension = config.vae_dim
+        encoder_config.n_filters = config.encoder_n_filters
+        encoder_config.ratios = config.encoder_ratios
+        encoder_config.depths = encoder_depths
+        encoder_config.norm = config.conv_norm
+        encoder_config.pad_mode = config.pad_mode
+        encoder_config.bias = config.conv_bias
+        encoder_config.layernorm_eps = config.layernorm_eps
+        encoder_config.layernorm_elementwise_affine = config.layernorm_elementwise_affine
+        encoder_config.mixer_layer = config.mixer_layer
+        encoder_config.layer_scale_init_value = config.layer_scale_init_value
+        encoder_config.disable_last_norm = config.disable_last_norm
+        
+        # Create decoder config
+        decoder_config = copy.deepcopy(config)
+        decoder_config.dimension = config.vae_dim
+        decoder_config.n_filters = config.decoder_n_filters
+        decoder_config.ratios = config.decoder_ratios
+        decoder_config.depths = decoder_depths
+        decoder_config.norm = config.conv_norm
+        decoder_config.pad_mode = config.pad_mode
+        decoder_config.bias = config.conv_bias
+        decoder_config.layernorm_eps = config.layernorm_eps
+        decoder_config.layernorm_elementwise_affine = config.layernorm_elementwise_affine
+        decoder_config.mixer_layer = config.mixer_layer
+        decoder_config.layer_scale_init_value = config.layer_scale_init_value
+        decoder_config.disable_last_norm = config.disable_last_norm
+        
+        # Initialize encoder and decoder
+        self.encoder = TokenizerEncoder(encoder_config)
+        self.decoder = TokenizerDecoder(decoder_config)
+        
+        # Initialize weights
+        self.apply(self._init_weights)
+    
+    def _init_weights(self, module):
+        """Initialize weights for the model"""
+        if isinstance(module, nn.Linear):
+            nn.init.normal_(module.weight, std=self.config.weight_init_value)
+            if module.bias is not None:
+                nn.init.zeros_(module.bias)
+        elif isinstance(module, nn.LayerNorm):
+            nn.init.ones_(module.weight)
+            nn.init.zeros_(module.bias)
+        elif isinstance(module, nn.Conv1d):
+            nn.init.normal_(module.weight, std=self.config.weight_init_value)
+            if module.bias is not None:
+                nn.init.zeros_(module.bias)
+    
+    @torch.no_grad()
+    def encode(self, audio, cache=None, sample_indices=None, use_cache=False, debug=False):
+        """Convert audio to latent representations"""
+        latents = self.encoder(audio, cache=cache, sample_indices=sample_indices, use_cache=use_cache, debug=debug)
+        return VibeVoiceTokenizerEncoderOutput(mean=latents.permute(0, 2, 1), std=self.fix_std)
+    
+    @torch.no_grad()
+    def sampling(self, encoder_output, dist_type=None):
+        """Sample from the encoder output distribution"""
+        dist_type = dist_type or self.std_dist_type
+    
+        if dist_type == 'fix':
+            return encoder_output.sample(dist_type='fix')
+        elif dist_type == 'gaussian':
+            return encoder_output.sample(dist_type='gaussian')
+        else:
+            raise ValueError(f"Unsupported dist_type: {dist_type}, expected 'fix' or 'gaussian'")
+    
+    @torch.no_grad()
+    def decode(self, latents, cache=None, sample_indices=None, use_cache=False, debug=False):
+        """Convert latent representations back to audio"""
+        if latents.shape[1] == self.config.vae_dim:
+            pass
+        else:
+            latents = latents.permute(0, 2, 1)
+
+        audio = self.decoder(latents, cache=cache, sample_indices=sample_indices, use_cache=use_cache, debug=debug)
+        return audio
+
+    def forward(self, audio, cache=None, sample_indices=None, use_cache=False, debug=False):
+        """Full forward pass: encode audio to latents, then decode back to audio"""
+        encoder_output = self.encode(audio, cache=cache, sample_indices=sample_indices, use_cache=use_cache, debug=debug)
+        sampled_latents, _ = self.sampling(encoder_output)
+        reconstructed = self.decode(sampled_latents, cache=cache, sample_indices=sample_indices, use_cache=use_cache, debug=debug)
+        return reconstructed, sampled_latents
+
+
+class VibeVoiceSemanticTokenizerModel(PreTrainedModel):
+    """VibeVoice speech tokenizer model with only encoder for semantic tokens"""
+    
+    config_class = VibeVoiceSemanticTokenizerConfig
+    base_model_prefix = "vibevoice_semantic_tokenizer"
+    _supports_flash_attn_2 = True  
+    _supports_sdpa = True  
+    _no_split_modules = ["TokenizerEncoder"]
+    
+    def __init__(self, config):
+        super().__init__(config)
+        
+        # Parse encoder depths
+        if isinstance(config.encoder_depths, str):
+            encoder_depths = [int(d) for d in config.encoder_depths.split('-')]
+        else:
+            encoder_depths = config.encoder_depths
+        
+        # Create encoder config
+        encoder_config = copy.deepcopy(config)
+        encoder_config.dimension = config.vae_dim
+        encoder_config.n_filters = config.encoder_n_filters
+        encoder_config.ratios = config.encoder_ratios
+        encoder_config.depths = encoder_depths
+        encoder_config.norm = config.conv_norm
+        encoder_config.pad_mode = config.pad_mode
+        encoder_config.bias = config.conv_bias
+        encoder_config.layernorm_eps = config.layernorm_eps
+        encoder_config.layernorm_elementwise_affine = config.layernorm_elementwise_affine
+        encoder_config.mixer_layer = config.mixer_layer
+        encoder_config.layer_scale_init_value = config.layer_scale_init_value
+        encoder_config.disable_last_norm = config.disable_last_norm
+        
+        # Initialize encoder and decoder
+        self.encoder = TokenizerEncoder(encoder_config)
+        
+        # Initialize weights
+        self.apply(self._init_weights)
+    
+    def _init_weights(self, module):
+        """Initialize weights for the model"""
+        if isinstance(module, nn.Linear):
+            nn.init.normal_(module.weight, std=self.config.weight_init_value)
+            if module.bias is not None:
+                nn.init.zeros_(module.bias)
+        elif isinstance(module, nn.LayerNorm):
+            nn.init.ones_(module.weight)
+            nn.init.zeros_(module.bias)
+        elif isinstance(module, nn.Conv1d):
+            nn.init.normal_(module.weight, std=self.config.weight_init_value)
+            if module.bias is not None:
+                nn.init.zeros_(module.bias)
+    
+    @torch.no_grad()
+    def encode(self, audio, cache=None, sample_indices=None, use_cache=False, debug=False):
+        """Convert audio to latent representations"""
+        latents = self.encoder(audio, cache=cache, sample_indices=sample_indices, use_cache=use_cache, debug=debug)
+        return VibeVoiceTokenizerEncoderOutput(mean=latents.permute(0, 2, 1))
+    
+    @torch.no_grad()
+    def sampling(self, encoder_output, dist_type=None):
+        """Sample from the encoder output distribution"""
+        return encoder_output.sample(dist_type='none')
+
+    def forward(self, audio, cache=None, sample_indices=None, use_cache=False, debug=False):
+        """Full forward pass: encode audio to latents, then decode back to audio"""
+        encoder_output = self.encode(audio, cache=cache, sample_indices=sample_indices, use_cache=use_cache, debug=debug)
+        sampled_latents, _ = self.sampling(encoder_output, dist_type='none')
+        return None, sampled_latents
+
+AutoModel.register(VibeVoiceAcousticTokenizerConfig, VibeVoiceAcousticTokenizerModel, exist_ok=True)
+AutoModel.register(VibeVoiceSemanticTokenizerConfig, VibeVoiceSemanticTokenizerModel, exist_ok=True)
+
+__all__ = [
+    "VibeVoiceTokenizerStreamingCache",
+    "VibeVoiceAcousticTokenizerModel",
+    "VibeVoiceSemanticTokenizerModel",
+]

VibeVoice-tpu/src/vibevoice/modular/streamer.py

@@ -0,0 +1,264 @@
+from __future__ import annotations
+
+import torch
+
+import asyncio
+from queue import Queue
+from typing import TYPE_CHECKING, Optional
+
+
+from transformers.generation import BaseStreamer
+
+
+class AudioStreamer(BaseStreamer):
+    """
+    Audio streamer that stores audio chunks in queues for each sample in the batch.
+    This allows streaming audio generation for multiple samples simultaneously.
+    
+    Parameters:
+        batch_size (`int`):
+            The batch size for generation
+        stop_signal (`any`, *optional*):
+            The signal to put in the queue when generation ends. Defaults to None.
+        timeout (`float`, *optional*):
+            The timeout for the audio queue. If `None`, the queue will block indefinitely.
+    """
+    
+    def __init__(
+        self, 
+        batch_size: int,
+        stop_signal: Optional[any] = None,
+        timeout: Optional[float] = None,
+    ):
+        self.batch_size = batch_size
+        self.stop_signal = stop_signal
+        self.timeout = timeout
+        
+        # Create a queue for each sample in the batch
+        self.audio_queues = [Queue() for _ in range(batch_size)]
+        self.finished_flags = [False for _ in range(batch_size)]
+        self.sample_indices_map = {}  # Maps from sample index to queue index
+        
+    def put(self, audio_chunks: torch.Tensor, sample_indices: torch.Tensor):
+        """
+        Receives audio chunks and puts them in the appropriate queues.
+        
+        Args:
+            audio_chunks: Tensor of shape (num_samples, ...) containing audio chunks
+            sample_indices: Tensor indicating which samples these chunks belong to
+        """
+        for i, sample_idx in enumerate(sample_indices):
+            idx = sample_idx.item()
+            if idx < self.batch_size and not self.finished_flags[idx]:
+                # Convert to numpy or keep as tensor based on preference
+                audio_chunk = audio_chunks[i].detach().cpu()
+                self.audio_queues[idx].put(audio_chunk, timeout=self.timeout)
+    
+    def end(self, sample_indices: Optional[torch.Tensor] = None):
+        """
+        Signals the end of generation for specified samples or all samples.
+        
+        Args:
+            sample_indices: Optional tensor of sample indices to end. If None, ends all.
+        """
+        if sample_indices is None:
+            # End all samples
+            for idx in range(self.batch_size):
+                if not self.finished_flags[idx]:
+                    self.audio_queues[idx].put(self.stop_signal, timeout=self.timeout)
+                    self.finished_flags[idx] = True
+        else:
+            # End specific samples
+            for sample_idx in sample_indices:
+                idx = sample_idx.item() if torch.is_tensor(sample_idx) else sample_idx
+                if idx < self.batch_size and not self.finished_flags[idx]:
+                    self.audio_queues[idx].put(self.stop_signal, timeout=self.timeout)
+                    self.finished_flags[idx] = True
+    
+    def __iter__(self):
+        """Returns an iterator over the batch of audio streams."""
+        return AudioBatchIterator(self)
+    
+    def get_stream(self, sample_idx: int):
+        """Get the audio stream for a specific sample."""
+        if sample_idx >= self.batch_size:
+            raise ValueError(f"Sample index {sample_idx} exceeds batch size {self.batch_size}")
+        return AudioSampleIterator(self, sample_idx)
+
+
+class AudioSampleIterator:
+    """Iterator for a single audio stream from the batch."""
+    
+    def __init__(self, streamer: AudioStreamer, sample_idx: int):
+        self.streamer = streamer
+        self.sample_idx = sample_idx
+        
+    def __iter__(self):
+        return self
+    
+    def __next__(self):
+        value = self.streamer.audio_queues[self.sample_idx].get(timeout=self.streamer.timeout)
+        if value == self.streamer.stop_signal:
+            raise StopIteration()
+        return value
+
+
+class AudioBatchIterator:
+    """Iterator that yields audio chunks for all samples in the batch."""
+    
+    def __init__(self, streamer: AudioStreamer):
+        self.streamer = streamer
+        self.active_samples = set(range(streamer.batch_size))
+        
+    def __iter__(self):
+        return self
+    
+    def __next__(self):
+        if not self.active_samples:
+            raise StopIteration()
+            
+        batch_chunks = {}
+        samples_to_remove = set()
+        
+        # Try to get chunks from all active samples
+        for idx in self.active_samples:
+            try:
+                value = self.streamer.audio_queues[idx].get(block=False)
+                if value == self.streamer.stop_signal:
+                    samples_to_remove.add(idx)
+                else:
+                    batch_chunks[idx] = value
+            except:
+                # Queue is empty for this sample, skip it this iteration
+                pass
+        
+        # Remove finished samples
+        self.active_samples -= samples_to_remove
+        
+        if batch_chunks:
+            return batch_chunks
+        elif self.active_samples:
+            # If no chunks were ready but we still have active samples, 
+            # wait a bit and try again
+            import time
+            time.sleep(0.01)
+            return self.__next__()
+        else:
+            raise StopIteration()
+
+
+class AsyncAudioStreamer(AudioStreamer):
+    """
+    Async version of AudioStreamer for use in async contexts.
+    """
+    
+    def __init__(
+        self, 
+        batch_size: int,
+        stop_signal: Optional[any] = None,
+        timeout: Optional[float] = None,
+    ):
+        super().__init__(batch_size, stop_signal, timeout)
+        # Replace regular queues with async queues
+        self.audio_queues = [asyncio.Queue() for _ in range(batch_size)]
+        self.loop = asyncio.get_running_loop()
+        
+    def put(self, audio_chunks: torch.Tensor, sample_indices: torch.Tensor):
+        """Put audio chunks in the appropriate async queues."""
+        for i, sample_idx in enumerate(sample_indices):
+            idx = sample_idx.item()
+            if idx < self.batch_size and not self.finished_flags[idx]:
+                audio_chunk = audio_chunks[i].detach().cpu()
+                self.loop.call_soon_threadsafe(
+                    self.audio_queues[idx].put_nowait, audio_chunk
+                )
+    
+    def end(self, sample_indices: Optional[torch.Tensor] = None):
+        """Signal the end of generation for specified samples."""
+        if sample_indices is None:
+            indices_to_end = range(self.batch_size)
+        else:
+            indices_to_end = [s.item() if torch.is_tensor(s) else s for s in sample_indices]
+            
+        for idx in indices_to_end:
+            if idx < self.batch_size and not self.finished_flags[idx]:
+                self.loop.call_soon_threadsafe(
+                    self.audio_queues[idx].put_nowait, self.stop_signal
+                )
+                self.finished_flags[idx] = True
+    
+    async def get_stream(self, sample_idx: int):
+        """Get async iterator for a specific sample's audio stream."""
+        if sample_idx >= self.batch_size:
+            raise ValueError(f"Sample index {sample_idx} exceeds batch size {self.batch_size}")
+            
+        while True:
+            value = await self.audio_queues[sample_idx].get()
+            if value == self.stop_signal:
+                break
+            yield value
+    
+    def __aiter__(self):
+        """Returns an async iterator over all audio streams."""
+        return AsyncAudioBatchIterator(self)
+
+
+class AsyncAudioBatchIterator:
+    """Async iterator for batch audio streaming."""
+    
+    def __init__(self, streamer: AsyncAudioStreamer):
+        self.streamer = streamer
+        self.active_samples = set(range(streamer.batch_size))
+        
+    def __aiter__(self):
+        return self
+        
+    async def __anext__(self):
+        if not self.active_samples:
+            raise StopAsyncIteration()
+            
+        batch_chunks = {}
+        samples_to_remove = set()
+        
+        # Create tasks for all active samples
+        tasks = {
+            idx: asyncio.create_task(self._get_chunk(idx)) 
+            for idx in self.active_samples
+        }
+        
+        # Wait for at least one chunk to be ready
+        done, pending = await asyncio.wait(
+            tasks.values(), 
+            return_when=asyncio.FIRST_COMPLETED,
+            timeout=self.streamer.timeout
+        )
+        
+        # Cancel pending tasks
+        for task in pending:
+            task.cancel()
+            
+        # Process completed tasks
+        for idx, task in tasks.items():
+            if task in done:
+                try:
+                    value = await task
+                    if value == self.streamer.stop_signal:
+                        samples_to_remove.add(idx)
+                    else:
+                        batch_chunks[idx] = value
+                except asyncio.CancelledError:
+                    pass
+                    
+        self.active_samples -= samples_to_remove
+        
+        if batch_chunks:
+            return batch_chunks
+        elif self.active_samples:
+            # Try again if we still have active samples
+            return await self.__anext__()
+        else:
+            raise StopAsyncIteration()
+    
+    async def _get_chunk(self, idx):
+        """Helper to get a chunk from a specific queue."""
+        return await self.streamer.audio_queues[idx].get()

VibeVoice-tpu/src/vibevoice/processor/preprocessor_config.json

@@ -0,0 +1,13 @@
+{
+  "processor_class": "VibeVoiceProcessor",
+  "speech_tok_compress_ratio": 3200,
+  "db_normalize": true,
+  "audio_processor": {
+    "feature_extractor_type": "VibeVoiceTokenizerProcessor",
+    "sampling_rate": 24000,
+    "normalize_audio": true,
+    "target_dB_FS": -25,
+    "eps": 1e-06
+  },
+  "language_model_pretrained_name": "Qwen/Qwen2.5-7B"
+}

VibeVoice-tpu/src/vibevoice/processor/vibevoice_processor.py

@@ -0,0 +1,677 @@
+import math
+import warnings
+from typing import List, Optional, Union, Dict, Any, Tuple
+import os
+import re
+
+import numpy as np
+import torch
+
+from transformers.tokenization_utils_base import BatchEncoding, PaddingStrategy, PreTokenizedInput, TextInput, TruncationStrategy
+from transformers.utils import TensorType, logging
+from .vibevoice_tokenizer_processor import AudioNormalizer
+
+logger = logging.get_logger(__name__)
+
+
+class VibeVoiceProcessor:
+    r"""
+    Constructs a VibeVoice processor which wraps a VibeVoice tokenizer and audio processor into a single processor.
+
+    [`VibeVoiceProcessor`] offers all the functionalities of [`VibeVoiceTokenizer`] and [`VibeVoiceTokenizerProcessor`]. 
+    See the [`~VibeVoiceProcessor.__call__`] and [`~VibeVoiceProcessor.decode`] for more information.
+
+    Args:
+        tokenizer (`VibeVoiceTextTokenizer` or `VibeVoiceTextTokenizerFast`):
+            The tokenizer for text processing.
+        audio_processor (`VibeVoiceTokenizerProcessor`):
+            The audio processor for speech processing.
+        speech_tok_compress_ratio (`int`, *optional*, defaults to 3200):
+            The compression ratio for speech tokenization.
+        db_normalize (`bool`, *optional*, defaults to True):
+            Whether to apply decibel normalization to audio inputs.
+    """
+
+    def __init__(self, tokenizer=None, audio_processor=None, speech_tok_compress_ratio=3200, db_normalize=True, **kwargs):
+        self.tokenizer = tokenizer
+        self.audio_processor = audio_processor
+        self.speech_tok_compress_ratio = speech_tok_compress_ratio
+        self.db_normalize = db_normalize
+        self.audio_normalizer = AudioNormalizer() if db_normalize else None
+        self.system_prompt = " Transform the text provided by various speakers into speech output, utilizing the distinct voice of each respective speaker.\n"
+
+    @classmethod
+    def from_pretrained(cls, pretrained_model_name_or_path, **kwargs):
+        """
+        Instantiate a VibeVoiceProcessor from a pretrained VibeVoice processor.
+
+        Args:
+            pretrained_model_name_or_path (`str` or `os.PathLike`):
+                This can be either:
+                - a string, the *model id* of a pretrained model
+                - a path to a *directory* containing processor config
+
+        Returns:
+            [`VibeVoiceProcessor`]: The processor object instantiated from pretrained model.
+        """
+        import os
+        import json
+        from .vibevoice_tokenizer_processor import VibeVoiceTokenizerProcessor
+        from vibevoice.modular.modular_vibevoice_text_tokenizer import (
+            VibeVoiceTextTokenizer, 
+            VibeVoiceTextTokenizerFast
+        )
+        
+        # Load processor configuration
+        config_path = os.path.join(pretrained_model_name_or_path, "preprocessor_config.json")
+        if os.path.exists(config_path):
+            with open(config_path, 'r') as f:
+                config = json.load(f)
+        else:
+            logger.warning(f"No preprocessor_config.json found at {pretrained_model_name_or_path}, using defaults")
+            config = {
+                "speech_tok_compress_ratio": 3200,
+                "db_normalize": True,
+            }
+        
+        # Extract main processor parameters
+        speech_tok_compress_ratio = config.get("speech_tok_compress_ratio", 3200)
+        db_normalize = config.get("db_normalize", True)
+        
+        # Load tokenizer - try from model path first, then fallback to Qwen        
+        language_model_pretrained_name = config.get("language_model_pretrained_name", None) or kwargs.pop("language_model_pretrained_name", "Qwen/Qwen2.5-1.5B")
+        logger.info(f"Loading tokenizer from {language_model_pretrained_name}")
+        if 'qwen' in language_model_pretrained_name.lower():
+            tokenizer = VibeVoiceTextTokenizerFast.from_pretrained(
+                language_model_pretrained_name,
+                **kwargs
+            )
+        else:
+            raise ValueError(f"Unsupported tokenizer type for {language_model_pretrained_name}. Supported types: Qwen, Llama, Gemma.")
+        
+        # Load audio processor
+        if "audio_processor" in config:
+            # Create audio processor from config
+            audio_config = config["audio_processor"]
+            audio_processor = VibeVoiceTokenizerProcessor(
+                sampling_rate=audio_config.get("sampling_rate", 24000),
+                normalize_audio=audio_config.get("normalize_audio", True),
+                target_dB_FS=audio_config.get("target_dB_FS", -25),
+                eps=audio_config.get("eps", 1e-6),
+            )
+        else:
+            # Create default audio processor
+            audio_processor = VibeVoiceTokenizerProcessor()
+        
+        # Create and return the processor
+        return cls(
+            tokenizer=tokenizer,
+            audio_processor=audio_processor,
+            speech_tok_compress_ratio=speech_tok_compress_ratio,
+            db_normalize=db_normalize,
+        )
+    
+    def save_pretrained(self, save_directory: Union[str, os.PathLike], **kwargs):
+        """
+        Save a processor to a directory, so that it can be re-loaded using the
+        [`~VibeVoiceProcessor.from_pretrained`] class method.
+
+        Args:
+            save_directory (`str` or `os.PathLike`):
+                Directory where the processor will be saved.
+        """
+        import os
+        import json
+        
+        os.makedirs(save_directory, exist_ok=True)
+        
+        # Save processor configuration
+        processor_config = {
+            "processor_class": "VibeVoiceProcessor",
+            "speech_tok_compress_ratio": self.speech_tok_compress_ratio,
+            "db_normalize": self.db_normalize,
+            "audio_processor": {
+                "feature_extractor_type": "VibeVoiceTokenizerProcessor",
+                "sampling_rate": getattr(self.audio_processor, 'sampling_rate', 24000),
+                "normalize_audio": getattr(self.audio_processor, 'normalize_audio', True),
+                "target_dB_FS": getattr(self.audio_processor, 'target_dB_FS', -25),
+                "eps": getattr(self.audio_processor, 'eps', 1e-6),
+            }
+        }
+        
+        config_path = os.path.join(save_directory, "preprocessor_config.json")
+        with open(config_path, 'w') as f:
+            json.dump(processor_config, f, indent=2)
+        
+        logger.info(f"Processor configuration saved in {config_path}")
+    
+    def __call__(
+        self,
+        text: Optional[Union[str, List[str], TextInput, PreTokenizedInput, List[TextInput], List[PreTokenizedInput]]] = None,
+        voice_samples: Optional[Union[List[Union[str, np.ndarray]], List[List[Union[str, np.ndarray]]]]] = None,
+        padding: Union[bool, str, PaddingStrategy] = True,
+        truncation: Union[bool, str, TruncationStrategy] = False,
+        max_length: Optional[int] = None,
+        return_tensors: Optional[Union[str, TensorType]] = None,
+        return_attention_mask: bool = True,
+        **kwargs,
+    ) -> BatchEncoding:
+        """
+        Main method to process one or more podcast scripts with optional voice samples.
+
+        Args:
+            text (`str`, `List[str]`):
+                The input text(s) to process. Can be:
+                - A single script string
+                - A list of script strings for batch processing
+                - A path to a .json or .txt file
+                - A list of paths
+            voice_samples (`List[Union[str, np.ndarray]]`, `List[List[Union[str, np.ndarray]]]`, *optional*):
+                Voice samples for each script. Can be:
+                - A list of samples for a single script
+                - A list of lists for batch processing
+            padding (`bool`, `str` or `PaddingStrategy`, defaults to `True`):
+                Whether to pad sequences to the same length
+            truncation (`bool`, `str` or `TruncationStrategy`, defaults to `False`):
+                Whether to truncate sequences
+            max_length (`int`, *optional*):
+                Maximum length of the returned sequences
+            return_tensors (`str` or `TensorType`, *optional*):
+                If set, will return tensors of a particular framework
+            return_attention_mask (`bool`, defaults to `True`):
+                Whether to return the attention mask
+
+        Returns:
+            `BatchEncoding`: A BatchEncoding with the following fields:
+                - **input_ids** -- List of token id sequences or tensor
+                - **attention_mask** -- List of attention masks or tensor
+                - **speech_tensors** -- Padded speech inputs (if voice_samples provided)
+                - **speech_masks** -- Speech masks (if voice_samples provided)
+                - **speech_input_mask** -- Boolean masks indicating speech token positions
+        """
+        # Handle single vs batch input
+        if isinstance(text, str) or (isinstance(text, list) and len(text) > 0 and not isinstance(text[0], str)):
+            # Single input
+            texts = [text]
+            is_batched = False
+        else:
+            # Batch input
+            texts = text
+            is_batched = True
+            
+        # Handle voice samples
+        if voice_samples is not None:
+            if not is_batched or (isinstance(voice_samples[0], (str, np.ndarray))):
+                # Single set of voice samples
+                voice_samples_list = [voice_samples]
+            else:
+                # Batch of voice samples
+                voice_samples_list = voice_samples
+        else:
+            voice_samples_list = [None] * len(texts)
+        
+        # Process each input
+        all_encodings = []
+        for text_input, voice_input in zip(texts, voice_samples_list):
+            encoding = self._process_single(text_input, voice_input)
+            all_encodings.append(encoding)
+            
+        # Combine batch
+        batch_encoding = self._batch_encode(
+            all_encodings,
+            padding=padding,
+            truncation=truncation,
+            max_length=max_length,
+            return_tensors=return_tensors,
+            return_attention_mask=return_attention_mask,
+        )
+        
+        return batch_encoding
+    
+    def _process_single(
+        self,
+        text: Union[str, TextInput],
+        voice_samples: Optional[List[Union[str, np.ndarray]]] = None,
+    ) -> Dict[str, Any]:
+        """Process a single podcast script."""
+        # Determine if text is a file path or direct script
+        script = None
+        if isinstance(text, str):
+            # Check if it's a file path
+            if text.endswith('.json') and os.path.exists(text):
+                script = self._convert_json_to_script(text)
+            elif text.endswith('.txt') and os.path.exists(text):
+                script = self._convert_text_to_script(text)
+            else:
+                # Assume it's the script content directly
+                script = text
+        
+        if script is None:
+            raise ValueError(f"Could not process input text: {text}")
+        
+        # Parse the script
+        parsed_lines = self._parse_script(script)
+        all_speakers = list(set(speaker_id for speaker_id, _ in parsed_lines))
+        
+        # Create system prompt
+        # system_tokens = self.tokenizer.encode(self.system_prompt, add_special_tokens=False)
+        system_tokens = self.tokenizer.encode(self.system_prompt)
+        
+        # Process voice samples if provided
+        if voice_samples:
+            voice_tokens, voice_speech_inputs, voice_speech_masks = self._create_voice_prompt(voice_samples[:len(all_speakers)])
+        else:
+            voice_tokens, voice_speech_inputs, voice_speech_masks = [], [], []
+        
+        # Build full token sequence
+        full_tokens = system_tokens + voice_tokens
+        speech_input_mask = [False] * len(system_tokens) + voice_speech_masks
+        
+        # Add text input section
+        full_tokens += self.tokenizer.encode(' Text input:\n', add_special_tokens=False)
+        speech_input_mask += [False] * len(self.tokenizer.encode(' Text input:\n', add_special_tokens=False))
+        
+        for speaker_id, speaker_text in parsed_lines:
+            speaker_text_tokens = self.tokenizer.encode(f" Speaker {speaker_id}:{speaker_text}\n", add_special_tokens=False)
+            full_tokens += speaker_text_tokens
+            speech_input_mask += [False] * len(speaker_text_tokens)
+        
+        # Add speech output section
+        full_tokens += self.tokenizer.encode(' Speech output:\n', add_special_tokens=False) + [self.tokenizer.speech_start_id]
+        speech_input_mask += [False] * (len(self.tokenizer.encode(' Speech output:\n', add_special_tokens=False)) + 1)
+        
+        return {
+            "input_ids": full_tokens,
+            "speech_inputs": voice_speech_inputs if voice_speech_inputs else None,
+            "speech_input_mask": speech_input_mask,
+            "parsed_script": parsed_lines,
+            "all_speakers": all_speakers,
+        }
+    
+    def _batch_encode(
+        self,
+        encodings: List[Dict[str, Any]],
+        padding: Union[bool, str, PaddingStrategy] = True,
+        truncation: Union[bool, str, TruncationStrategy] = False,
+        max_length: Optional[int] = None,
+        return_tensors: Optional[Union[str, TensorType]] = None,
+        return_attention_mask: bool = True,
+    ) -> BatchEncoding:
+        """Combine multiple encodings into a batch with padding."""
+        # Extract input_ids and create attention_mask
+        input_ids_list = [enc["input_ids"] for enc in encodings]
+        speech_input_masks_list = [enc["speech_input_mask"] for enc in encodings]
+        
+        # Determine padding strategy
+        if isinstance(padding, bool):
+            padding_strategy = PaddingStrategy.LONGEST if padding else PaddingStrategy.DO_NOT_PAD
+        elif isinstance(padding, str):
+            padding_strategy = PaddingStrategy(padding)
+        else:
+            padding_strategy = padding
+            
+        # Apply padding to input_ids
+        if padding_strategy != PaddingStrategy.DO_NOT_PAD:
+            if padding_strategy == PaddingStrategy.LONGEST:
+                max_len = max(len(ids) for ids in input_ids_list)
+            elif padding_strategy == PaddingStrategy.MAX_LENGTH and max_length is not None:
+                max_len = max_length
+            else:
+                max_len = max(len(ids) for ids in input_ids_list)
+                
+            # Pad sequences
+            padded_input_ids = []
+            attention_masks = []
+            padded_speech_input_masks = []
+            
+            for input_ids, speech_mask in zip(input_ids_list, speech_input_masks_list):
+                # Truncate if needed
+                if truncation and len(input_ids) > max_len:
+                    input_ids = input_ids[:max_len]
+                    speech_mask = speech_mask[:max_len]
+                    
+                # Pad
+                padding_length = max_len - len(input_ids)
+                # padded_ids = [self.tokenizer.pad_token_id] * padding_length + input_ids
+                padded_ids = [self.tokenizer.pad_id] * padding_length + input_ids
+                attention_mask = [0] * padding_length + [1] * len(input_ids)
+                padded_speech_mask = [False] * padding_length + speech_mask
+                
+                padded_input_ids.append(padded_ids)
+                attention_masks.append(attention_mask)
+                padded_speech_input_masks.append(padded_speech_mask)
+                
+            input_ids_list = padded_input_ids
+            speech_input_masks_list = padded_speech_input_masks
+        else:
+            # No padding, just create attention masks
+            attention_masks = [[1] * len(ids) for ids in input_ids_list] if return_attention_mask else None
+            
+        # Process speech inputs
+        all_speech_inputs = []
+        has_speech = False
+        for enc in encodings:
+            if enc["speech_inputs"] is not None:
+                all_speech_inputs.extend(enc["speech_inputs"])
+                has_speech = True
+                
+        # Prepare batch encoding
+        batch_encoding = BatchEncoding()
+        
+        # Handle tensor conversion
+        if return_tensors is not None:
+            batch_encoding["input_ids"] = torch.tensor(input_ids_list, dtype=torch.long)
+            if return_attention_mask and attention_masks is not None:
+                batch_encoding["attention_mask"] = torch.tensor(attention_masks, dtype=torch.long)
+            batch_encoding["speech_input_mask"] = torch.tensor(speech_input_masks_list, dtype=torch.bool)
+        else:
+            batch_encoding["input_ids"] = input_ids_list
+            if return_attention_mask and attention_masks is not None:
+                batch_encoding["attention_mask"] = attention_masks
+            batch_encoding["speech_input_mask"] = speech_input_masks_list
+            
+        # Process speech tensors if present
+        if has_speech:
+            speech_dict = self.prepare_speech_inputs(
+                all_speech_inputs,
+                return_tensors=return_tensors,
+            )
+            batch_encoding["speech_tensors"] = speech_dict["padded_speeches"]
+            batch_encoding["speech_masks"] = speech_dict["speech_masks"]
+        else:
+            batch_encoding["speech_tensors"] = None
+            batch_encoding["speech_masks"] = None
+            
+        # Add metadata
+        batch_encoding["parsed_scripts"] = [enc["parsed_script"] for enc in encodings]
+        batch_encoding["all_speakers_list"] = [enc["all_speakers"] for enc in encodings]
+        
+        return batch_encoding
+
+    def _create_voice_prompt(
+        self, 
+        speaker_samples: List[Union[str, np.ndarray]]
+    ) -> Tuple[List[int], List[np.ndarray], List[bool]]:
+        """
+        Create voice prompt tokens and process audio samples.
+        
+        Returns:
+            tuple: (voice_tokens, voice_speech_inputs, voice_speech_masks)
+        """
+        vae_token_id = self.tokenizer.speech_diffusion_id
+        
+        voice_full_tokens = self.tokenizer.encode(' Voice input:\n', add_special_tokens=False)
+        voice_speech_inputs = []
+        voice_speech_masks = [False] * len(voice_full_tokens)
+        
+        for speaker_id, speaker_audio in enumerate(speaker_samples):
+            prefix_tokens = self.tokenizer.encode(f" Speaker {speaker_id}:", add_special_tokens=False)
+            
+            # Process audio
+            if isinstance(speaker_audio, str):
+                # Load audio from file
+                wav = self.audio_processor._load_audio_from_path(speaker_audio)
+            else:
+                wav = np.array(speaker_audio, dtype=np.float32)
+            
+            # Apply normalization if needed
+            if self.db_normalize and self.audio_normalizer:
+                wav = self.audio_normalizer(wav)
+            
+            # Calculate token length based on compression ratio
+            # if speaker_audio.endswith('.pt') or speaker_audio.endswith('.npy'):
+            #     vae_tok_len = wav.shape[0]
+            # else:
+            vae_tok_len = math.ceil(wav.shape[0] / self.speech_tok_compress_ratio)
+            
+            # Build tokens and masks
+            speaker_tokens = (prefix_tokens + 
+                            [self.tokenizer.speech_start_id] + 
+                            [vae_token_id] * vae_tok_len + 
+                            [self.tokenizer.speech_end_id] + 
+                            self.tokenizer.encode('\n', add_special_tokens=False))
+            
+            vae_input_mask = ([False] * len(prefix_tokens) + 
+                            [False] + 
+                            [True] * vae_tok_len + 
+                            [False] + 
+                            [False])
+            
+            voice_full_tokens.extend(speaker_tokens)
+            voice_speech_masks.extend(vae_input_mask)
+            voice_speech_inputs.append(wav)
+            
+        return voice_full_tokens, voice_speech_inputs, voice_speech_masks
+
+    def prepare_speech_inputs(
+        self,
+        speech_inputs: List[np.ndarray],
+        return_tensors: Optional[Union[str, TensorType]] = None,
+        device: Optional[Union[str, torch.device]] = None,
+        dtype: Optional[torch.dtype] = None,
+    ) -> Dict[str, Any]:
+        """
+        Prepare speech inputs for model consumption.
+        
+        Args:
+            speech_inputs: List of speech arrays
+            return_tensors: Output tensor type
+            device: Device to place tensors on
+            dtype: Data type for tensors
+            
+        Returns:
+            Dictionary with padded_speeches and speech_masks
+        """
+        if not speech_inputs:
+            return {"padded_speeches": None, "speech_masks": None}
+        
+        # Calculate sequence lengths
+        vae_tok_seqlens = [math.ceil(s.shape[0] / self.speech_tok_compress_ratio) for s in speech_inputs]
+        # vae_tok_seqlens = [math.ceil(s.shape[0] / self.speech_tok_compress_ratio) if s.ndim == 1 else s.shape[0] for s in speech_inputs]
+        max_speech_length = max(s.shape[0] for s in speech_inputs)
+        
+        # Pad speeches
+        if speech_inputs[0].ndim == 1:
+            padded_speeches = np.full((len(speech_inputs), max_speech_length), fill_value=0, dtype=np.float32)
+        else:
+            padded_speeches = np.full((len(speech_inputs), max_speech_length, speech_inputs[0].shape[-1]), fill_value=0, dtype=np.float32)
+        speech_masks = np.zeros((len(speech_inputs), max(vae_tok_seqlens)), dtype=np.bool_)
+        
+        for i, (speech, vae_tok_length) in enumerate(zip(speech_inputs, vae_tok_seqlens)):
+            padded_speeches[i, :len(speech)] = speech
+            speech_masks[i, :vae_tok_length] = True
+        
+        result = {
+            "padded_speeches": padded_speeches,
+            "speech_masks": speech_masks,
+        }
+        
+        # Convert to tensors if requested
+        if return_tensors == "pt":
+            result["padded_speeches"] = torch.tensor(padded_speeches, device=device, dtype=dtype or torch.float32)
+            result["speech_masks"] = torch.tensor(speech_masks, device=device, dtype=torch.bool)
+            
+        return result
+        
+    def _convert_json_to_script(self, json_file: str) -> str:
+        """
+        Convert JSON format to script format.
+        Expected JSON format:
+        [
+            {"speaker": "1", "text": "Hello everyone..."},
+            {"speaker": "2", "text": "Great to be here..."}
+        ]
+        """
+        import json
+        
+        with open(json_file, 'r', encoding='utf-8') as f:
+            data = json.load(f)
+        
+        if not isinstance(data, list):
+            raise ValueError("JSON file must contain a list of speaker entries")
+        
+        script_lines = []
+        for item in data:
+            if not isinstance(item, dict):
+                logger.warning(f"Skipping non-dict entry: {item}")
+                continue
+                
+            speaker = item.get('speaker')
+            text = item.get('text')
+            
+            if speaker is None or text is None:
+                logger.warning(f"Skipping entry missing speaker or text: {item}")
+                continue
+            
+            # Ensure speaker ID is valid
+            try:
+                speaker_id = int(speaker)
+            except (ValueError, TypeError):
+                logger.warning(f"Invalid speaker ID: {speaker}, skipping entry")
+                continue
+            
+            # Clean up text
+            text = text.strip()
+            if text:
+                script_lines.append(f"Speaker {speaker_id}: {text}")
+        
+        if not script_lines:
+            raise ValueError("No valid entries found in JSON file")
+            
+        return "\n".join(script_lines)
+
+    def _convert_text_to_script(self, text_file: str) -> str:
+        """
+        Convert text file to script format.
+        Handles multiple formats:
+        1. Already formatted as "Speaker X: text"
+        2. Plain text (assigns to Speaker 1)
+        
+        Handles edge cases like multiple colons in a line.
+        """
+        with open(text_file, 'r', encoding='utf-8') as f:
+            lines = f.readlines()
+        
+        script_lines = []
+        current_speaker = 1
+        
+        for line in lines:
+            line = line.strip()
+            if not line:
+                continue
+            
+            # Try to parse as "Speaker X: text" format
+            # Use regex to be more robust
+            speaker_match = re.match(r'^Speaker\s+(\d+)\s*:\s*(.*)$', line, re.IGNORECASE)
+            
+            if speaker_match:
+                speaker_id = int(speaker_match.group(1))
+                text = speaker_match.group(2).strip()
+                if text:
+                    script_lines.append(f"Speaker {speaker_id}: {text}")
+            else:
+                # Treat as plain text - assign to current speaker
+                script_lines.append(f"Speaker {current_speaker}: {line}")
+        
+        if not script_lines:
+            raise ValueError("No valid content found in text file")
+            
+        return "\n".join(script_lines)
+
+    def _parse_script(self, script: str) -> List[Tuple[int, str]]:
+        """Parse script into list of (speaker_id, text) tuples."""
+        lines = script.strip().split("\n")
+        parsed_lines = []
+        speaker_ids = []
+                
+        # First pass: parse all lines and collect speaker IDs
+        for line in lines:
+            if not line.strip():
+                continue
+                
+            # Use regex to handle edge cases like multiple colons
+            match = re.match(r'^Speaker\s+(\d+)\s*:\s*(.*)$', line.strip(), re.IGNORECASE)
+            
+            if match:
+                speaker_id = int(match.group(1))
+                text = ' ' + match.group(2).strip()
+                parsed_lines.append((speaker_id, text))
+                speaker_ids.append(speaker_id)
+            else:
+                logger.warning(f"Could not parse line: '{line}'")
+        
+        if not parsed_lines:
+            raise ValueError("No valid speaker lines found in script")
+        
+        # Check if we need to normalize speaker IDs (only if all are > 0)
+        min_speaker_id = min(speaker_ids)
+        if min_speaker_id > 0:
+            # Normalize to start from 0
+            normalized_lines = []
+            for speaker_id, text in parsed_lines:
+                normalized_lines.append((speaker_id - 1, text))
+            return normalized_lines
+        else:
+            # Keep original IDs
+            return parsed_lines
+
+    def _merge_inputs(self, text_inputs: BatchEncoding, audio_inputs: Dict) -> BatchEncoding:
+        """Merge text and audio inputs into a single BatchEncoding."""
+        # Start with text inputs
+        merged = BatchEncoding(text_inputs)
+        
+        # Add audio-specific fields
+        if "audio" in audio_inputs:
+            merged["speech_inputs"] = audio_inputs["audio"]
+        if "streaming" in audio_inputs:
+            merged["streaming"] = audio_inputs["streaming"]
+            
+        return merged
+
+    def batch_decode(self, *args, **kwargs):
+        """
+        This method forwards all its arguments to VibeVoiceTextTokenizer's [`~PreTrainedTokenizer.batch_decode`].
+        Please refer to the docstring of this method for more information.
+        """
+        return self.tokenizer.batch_decode(*args, **kwargs)
+
+    def decode(self, *args, **kwargs):
+        """
+        This method forwards all its arguments to VibeVoiceTextTokenizer's [`~PreTrainedTokenizer.decode`].
+        Please refer to the docstring of this method for more information.
+        """
+        return self.tokenizer.decode(*args, **kwargs)
+
+    @property
+    def model_input_names(self):
+        """
+        Return the list of inputs accepted by the model.
+        """
+        tokenizer_input_names = self.tokenizer.model_input_names
+        audio_processor_input_names = self.audio_processor.model_input_names
+        return list(dict.fromkeys(tokenizer_input_names + audio_processor_input_names + ["speech_inputs", "speech_input_mask"]))
+
+    def save_audio(self, 
+        audio: Union[torch.Tensor, np.ndarray, List[Union[torch.Tensor, np.ndarray]]],
+        output_path: str = "output.wav",
+        sampling_rate: Optional[int] = None,
+        normalize: bool = False,
+        batch_prefix: str = "audio_",
+    ) -> str:
+        """
+        Save audio data to a file.
+        Args:
+            audio (Union[torch.Tensor, np.ndarray, List[Union[torch.Tensor, np.ndarray]]]):
+                The audio data to save. Can be a single tensor/array or a list of them.
+            output_path (str, optional): Path to save the audio file. Defaults to "output.wav".
+            sampling_rate (int, optional): Sampling rate for the audio. If None, uses the processor's default.
+            normalize (bool, optional): Whether to normalize the audio before saving. Defaults to False.
+            batch_prefix (str, optional): Prefix for batch audio files. Defaults to "audio_".
+        Returns:
+            str: The path to the saved audio file.
+        """
+        return self.audio_processor.save_audio(audio, output_path=output_path, sampling_rate=sampling_rate, normalize=normalize, batch_prefix=batch_prefix)
+    
+__all__ = [
+    "VibeVoiceProcessor",
+]

VibeVoice-tpu/src/vibevoice/processor/vibevoice_tokenizer_processor.py

@@ -0,0 +1,483 @@
+"""
+Processor class for VibeVoice models.
+"""
+
+import os
+import json
+import warnings
+from typing import List, Optional, Union, Dict, Any
+
+import numpy as np
+import torch
+
+from transformers.feature_extraction_utils import FeatureExtractionMixin
+from transformers.utils import logging
+
+logger = logging.get_logger(__name__)
+
+
+class AudioNormalizer:
+    """
+    Audio normalization class for VibeVoice tokenizer.
+    
+    This class provides audio normalization to ensure consistent input levels
+    for the VibeVoice tokenizer while maintaining audio quality.
+    """
+    
+    def __init__(self, target_dB_FS: float = -25, eps: float = 1e-6):
+        """
+        Initialize the audio normalizer.
+        
+        Args:
+            target_dB_FS (float): Target dB FS level for the audio. Default: -25
+            eps (float): Small value to avoid division by zero. Default: 1e-6
+        """
+        self.target_dB_FS = target_dB_FS
+        self.eps = eps
+    
+    def tailor_dB_FS(self, audio: np.ndarray) -> tuple:
+        """
+        Adjust the audio to the target dB FS level.
+        
+        Args:
+            audio (np.ndarray): Input audio signal
+            
+        Returns:
+            tuple: (normalized_audio, rms, scalar)
+        """
+        rms = np.sqrt(np.mean(audio**2))
+        scalar = 10 ** (self.target_dB_FS / 20) / (rms + self.eps)
+        normalized_audio = audio * scalar
+        return normalized_audio, rms, scalar
+    
+    def avoid_clipping(self, audio: np.ndarray, scalar: Optional[float] = None) -> tuple:
+        """
+        Avoid clipping by scaling down if necessary.
+        
+        Args:
+            audio (np.ndarray): Input audio signal
+            scalar (float, optional): Explicit scaling factor
+            
+        Returns:
+            tuple: (normalized_audio, scalar)
+        """
+        if scalar is None:
+            max_val = np.max(np.abs(audio))
+            if max_val > 1.0:
+                scalar = max_val + self.eps
+            else:
+                scalar = 1.0
+        
+        return audio / scalar, scalar
+    
+    def __call__(self, audio: np.ndarray) -> np.ndarray:
+        """
+        Normalize the audio by adjusting to target dB FS and avoiding clipping.
+        
+        Args:
+            audio (np.ndarray): Input audio signal
+            
+        Returns:
+            np.ndarray: Normalized audio signal
+        """
+        # First adjust to target dB FS
+        audio, _, _ = self.tailor_dB_FS(audio)
+        # Then avoid clipping
+        audio, _ = self.avoid_clipping(audio)
+        return audio
+
+
+# Change from ProcessorMixin to FeatureExtractionMixin which is designed for single components
+class VibeVoiceTokenizerProcessor(FeatureExtractionMixin):
+    """
+    Processor for VibeVoice acoustic tokenizer models.
+    
+    This processor handles audio preprocessing for VibeVoice models, including:
+    - Audio format conversion (stereo to mono)
+    - Optional audio normalization
+    - Streaming support for infinite-length audio
+    
+    Args:
+        sampling_rate (int, optional): Expected sampling rate. Defaults to 24000.
+        normalize_audio (bool, optional): Whether to normalize audio. Defaults to True.
+        target_dB_FS (float, optional): Target dB FS for normalization. Defaults to -25.
+        eps (float, optional): Small value for numerical stability. Defaults to 1e-6.
+    """
+    model_input_names = ["input_features"]
+    
+    def __init__(
+        self,
+        sampling_rate: int = 24000,
+        normalize_audio: bool = True,
+        target_dB_FS: float = -25,
+        eps: float = 1e-6,
+        **kwargs,
+    ):
+        super().__init__(**kwargs)
+        
+        self.sampling_rate = sampling_rate
+        self.normalize_audio = normalize_audio
+        
+        # Initialize audio normalizer if needed
+        if self.normalize_audio:
+            self.normalizer = AudioNormalizer(target_dB_FS=target_dB_FS, eps=eps)
+        else:
+            self.normalizer = None
+        
+        # Save config
+        self.feature_extractor_dict = {
+            "sampling_rate": sampling_rate,
+            "normalize_audio": normalize_audio,
+            "target_dB_FS": target_dB_FS,
+            "eps": eps,
+        }
+    
+    def _ensure_mono(self, audio: np.ndarray) -> np.ndarray:
+        """
+        Convert stereo audio to mono if needed.
+        
+        Args:
+            audio (np.ndarray): Input audio array
+            
+        Returns:
+            np.ndarray: Mono audio array
+        """
+        if len(audio.shape) == 1:
+            return audio
+        elif len(audio.shape) == 2:
+            if audio.shape[0] == 2:  # (2, time)
+                return np.mean(audio, axis=0)
+            elif audio.shape[1] == 2:  # (time, 2)
+                return np.mean(audio, axis=1)
+            else:
+                # If one dimension is 1, squeeze it
+                if audio.shape[0] == 1:
+                    return audio.squeeze(0)
+                elif audio.shape[1] == 1:
+                    return audio.squeeze(1)
+                else:
+                    raise ValueError(f"Unexpected audio shape: {audio.shape}")
+        else:
+            raise ValueError(f"Audio should be 1D or 2D, got shape: {audio.shape}")
+    
+    def _process_single_audio(self, audio: Union[np.ndarray, List[float]]) -> np.ndarray:
+        """
+        Process a single audio array.
+        
+        Args:
+            audio: Single audio input
+            
+        Returns:
+            np.ndarray: Processed audio
+        """
+        # Convert to numpy array
+        if not isinstance(audio, np.ndarray):
+            audio = np.array(audio, dtype=np.float32)
+        else:
+            audio = audio.astype(np.float32)
+        
+        # Ensure mono
+        audio = self._ensure_mono(audio)
+        
+        # Normalize if requested
+        if self.normalize_audio and self.normalizer is not None:
+            audio = self.normalizer(audio)
+        
+        return audio
+    
+    def __call__(
+        self,
+        audio: Union[str, np.ndarray, List[float], List[np.ndarray], List[List[float]], List[str]] = None,
+        sampling_rate: Optional[int] = None,
+        return_tensors: Optional[str] = None,
+        **kwargs,
+    ):
+        """
+        Process audio for VibeVoice models.
+        
+        Args:
+            audio: Audio input(s) to process. Can be:
+                - str: Path to audio file
+                - np.ndarray: Audio array
+                - List[float]: Audio as list of floats
+                - List[np.ndarray]: Batch of audio arrays
+                - List[str]: Batch of audio file paths
+            sampling_rate (int, optional): Sampling rate of the input audio
+            return_tensors (str, optional): Return format ('pt' for PyTorch, 'np' for NumPy)
+            
+        Returns:
+            dict: Processed audio inputs with keys:
+                - input_features: Audio tensor(s) ready for the model
+        """
+        if audio is None:
+            raise ValueError("Audio input is required")
+        
+        # Validate sampling rate
+        if sampling_rate is not None and sampling_rate != self.sampling_rate:
+            logger.warning(
+                f"Input sampling rate ({sampling_rate}) differs from expected "
+                f"sampling rate ({self.sampling_rate}). Please resample your audio."
+            )
+        
+        # Handle different input types
+        if isinstance(audio, str):
+            # Single audio file path
+            audio = self._load_audio_from_path(audio)
+            is_batched = False
+        elif isinstance(audio, list):
+            if len(audio) == 0:
+                raise ValueError("Empty audio list provided")
+            
+            # Check if it's a list of file paths
+            if all(isinstance(item, str) for item in audio):
+                # Batch of audio file paths
+                audio = [self._load_audio_from_path(path) for path in audio]
+                is_batched = True
+            else:
+                # Check if it's batched audio arrays
+                is_batched = isinstance(audio[0], (np.ndarray, list))
+        else:
+            # Single audio array or list
+            is_batched = False
+        
+        # Process audio
+        if is_batched:
+            processed_audio = [self._process_single_audio(a) for a in audio]
+        else:
+            processed_audio = [self._process_single_audio(audio)]
+        
+        # Convert to tensors if requested
+        if return_tensors == "pt":
+            if len(processed_audio) == 1:
+                # Create a proper batch dimension (B, T)
+                input_features = torch.from_numpy(processed_audio[0]).unsqueeze(0).unsqueeze(1)
+            else:
+                # For batched input with different lengths, create a batch properly
+                input_features = torch.stack([torch.from_numpy(a) for a in processed_audio]).unsqueeze(1)
+        elif return_tensors == "np":
+            if len(processed_audio) == 1:
+                input_features = processed_audio[0][np.newaxis, np.newaxis, :]
+            else:
+                input_features = np.stack(processed_audio)[:, np.newaxis, :]
+        else:
+            input_features = processed_audio[0] if len(processed_audio) == 1 else processed_audio
+        
+        outputs = {
+            "audio": input_features,  # Use "audio" instead of "input_features"
+        }
+        
+        return outputs
+
+    def _load_audio_from_path(self, audio_path: str) -> np.ndarray:
+        """
+        Load audio from file path.
+        
+        Args:
+            audio_path (str): Path to audio file
+            
+        Returns:
+            np.ndarray: Loaded audio array
+        """
+        # Get file extension to determine loading method
+        file_ext = os.path.splitext(audio_path)[1].lower()
+        
+        if file_ext in ['.wav', '.mp3', '.flac', '.m4a', '.ogg']:
+            # Audio file - use librosa
+            import librosa
+            audio_array, sr = librosa.load(
+                audio_path, 
+                sr=self.sampling_rate, 
+                mono=True
+            )
+            return audio_array
+        elif file_ext == '.pt':
+            # PyTorch tensor file
+            audio_tensor = torch.load(audio_path, map_location='cpu').squeeze()
+            if isinstance(audio_tensor, torch.Tensor):
+                audio_array = audio_tensor.numpy()
+            else:
+                audio_array = np.array(audio_tensor)
+            return audio_array.astype(np.float32)
+        elif file_ext == '.npy':
+            # NumPy file
+            audio_array = np.load(audio_path)
+            return audio_array.astype(np.float32)
+        else:
+            raise ValueError(
+                f"Unsupported file format: {file_ext}. "
+                f"Supported formats: .wav, .mp3, .flac, .m4a, .ogg, .pt, .npy, .npz"
+            )
+    
+    def preprocess_audio(
+        self, 
+        audio_path_or_array: Union[str, np.ndarray],
+        normalize: Optional[bool] = None,
+    ) -> np.ndarray:
+        """
+        Convenience method to preprocess audio from file path or array.
+        This method is kept for backward compatibility but __call__ is recommended.
+        
+        Args:
+            audio_path_or_array: Path to audio file or numpy array
+            normalize: Whether to normalize (overrides default setting)
+            
+        Returns:
+            np.ndarray: Preprocessed audio array
+        """
+        if isinstance(audio_path_or_array, str):
+            audio_array = self._load_audio_from_path(audio_path_or_array)
+        else:
+            audio_array = np.array(audio_path_or_array, dtype=np.float32)
+        
+        # Override normalization setting if specified
+        original_normalize = self.normalize_audio
+        if normalize is not None:
+            self.normalize_audio = normalize
+        
+        try:
+            processed = self._process_single_audio(audio_array)
+        finally:
+            # Restore original setting
+            self.normalize_audio = original_normalize
+        
+        return processed
+    
+    # Override to_dict method for configuration saving
+    def to_dict(self) -> Dict[str, Any]:
+        """
+        Convert the object to a dict containing all attributes needed for serialization.
+        """
+        return self.feature_extractor_dict
+
+    def save_audio(
+        self,
+        audio: Union[torch.Tensor, np.ndarray, List[Union[torch.Tensor, np.ndarray]]],
+        output_path: str = "output.wav",
+        sampling_rate: Optional[int] = None,
+        normalize: bool = False,
+        batch_prefix: str = "audio_",
+    ):
+        """
+        Save audio data to WAV file(s).
+        
+        Args:
+            audio: Audio data to save. Can be:
+                - torch.Tensor: PyTorch tensor with shape (B, C, T) or (B, T) or (T)
+                - np.ndarray: NumPy array with shape (B, C, T) or (B, T) or (T)
+                - List of tensors or arrays
+            output_path: Path where to save the audio. If saving multiple files,
+                this is treated as a directory and individual files will be saved inside.
+            sampling_rate: Sampling rate for the saved audio. Defaults to the processor's rate.
+            normalize: Whether to normalize audio before saving.
+            batch_prefix: Prefix for batch files when saving multiple audios.
+                
+        Returns:
+            List[str]: Paths to the saved audio files.
+        """
+        if sampling_rate is None:
+            sampling_rate = self.sampling_rate
+        
+        try:
+            import soundfile as sf
+        except ImportError:
+            raise ImportError(
+                "soundfile is required to save audio files. "
+                "Install it with: pip install soundfile"
+            )
+        
+        # Ensure audio is in the right format
+        if isinstance(audio, torch.Tensor):
+            # Convert PyTorch tensor to numpy
+            audio_np = audio.float().detach().cpu().numpy()
+        elif isinstance(audio, np.ndarray):
+            audio_np = audio
+        elif isinstance(audio, list):
+            # Handle list of tensors or arrays
+            if all(isinstance(a, torch.Tensor) for a in audio):
+                audio_np = [a.float().detach().cpu().numpy() for a in audio]
+            else:
+                audio_np = audio
+        else:
+            raise ValueError(f"Unsupported audio type: {type(audio)}")
+        
+        saved_paths = []
+        
+        # Handle based on shape or type
+        if isinstance(audio_np, list):
+            # Multiple separate audios to save
+            output_dir = output_path
+            
+            # Ensure output directory exists
+            os.makedirs(output_dir, exist_ok=True)
+            
+            # Save each audio
+            for i, audio_item in enumerate(audio_np):
+                audio_item = self._prepare_audio_for_save(audio_item, normalize)
+                file_path = os.path.join(output_dir, f"{batch_prefix}{i}.wav")
+                sf.write(file_path, audio_item, sampling_rate)
+                saved_paths.append(file_path)
+                
+        else:
+            # Handle different dimensions
+            if len(audio_np.shape) >= 3:  # (B, C, T) or similar
+                # Get batch size
+                batch_size = audio_np.shape[0]
+                
+                if batch_size > 1:
+                    # Multiple audios in a batch
+                    output_dir = output_path
+                    
+                    # Ensure output directory exists
+                    os.makedirs(output_dir, exist_ok=True)
+                    
+                    # Save each audio in the batch
+                    for i in range(batch_size):
+                        # Extract single audio and remove channel dim if present
+                        single_audio = audio_np[i]
+                        if len(single_audio.shape) > 1:
+                            if single_audio.shape[0] == 1:  # (1, T)
+                                single_audio = single_audio.squeeze(0)
+                        
+                        single_audio = self._prepare_audio_for_save(single_audio, normalize)
+                        file_path = os.path.join(output_dir, f"{batch_prefix}{i}.wav")
+                        sf.write(file_path, single_audio, sampling_rate)
+                        saved_paths.append(file_path)
+                else:
+                    # Single audio with batch and channel dims
+                    audio_item = audio_np.squeeze()  # Remove batch and channel dimensions
+                    audio_item = self._prepare_audio_for_save(audio_item, normalize)
+                    sf.write(output_path, audio_item, sampling_rate)
+                    saved_paths.append(output_path)
+            else:
+                # Single audio without batch dimension
+                audio_item = self._prepare_audio_for_save(audio_np, normalize)
+                sf.write(output_path, audio_item, sampling_rate)
+                saved_paths.append(output_path)
+        
+        return saved_paths
+
+    def _prepare_audio_for_save(self, audio: np.ndarray, normalize: bool) -> np.ndarray:
+        """
+        Prepare audio for saving by ensuring it's the right shape and optionally normalizing.
+        
+        Args:
+            audio: Audio data as numpy array
+            normalize: Whether to normalize audio
+            
+        Returns:
+            np.ndarray: Processed audio ready for saving
+        """
+        # Ensure right dimensionality
+        if len(audio.shape) > 1 and audio.shape[0] == 1:  # (1, T)
+            audio = audio.squeeze(0)
+        
+        # Normalize if requested
+        if normalize:
+            max_val = np.abs(audio).max()
+            if max_val > 0:
+                audio = audio / max_val
+        
+        return audio
+
+
+__all__ = ["VibeVoiceTokenizerProcessor", "AudioNormalizer"]

VibeVoice-tpu/src/vibevoice/schedule/dpm_solver.py

@@ -0,0 +1,1065 @@
+# Copyright 2024 TSAIL Team and The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# DISCLAIMER: This file is strongly influenced by https://github.com/LuChengTHU/dpm-solver
+
+import math
+from typing import List, Optional, Tuple, Union
+
+import numpy as np
+import torch
+
+from diffusers.configuration_utils import ConfigMixin, register_to_config
+from diffusers.utils import deprecate
+from diffusers.utils.torch_utils import randn_tensor
+from diffusers.schedulers.scheduling_utils import KarrasDiffusionSchedulers, SchedulerMixin, SchedulerOutput
+
+def betas_for_alpha_bar(
+    num_diffusion_timesteps,
+    max_beta=0.999,
+    alpha_transform_type="cosine",
+):
+    """
+    Create a beta schedule that discretizes the given alpha_t_bar function, which defines the cumulative product of
+    (1-beta) over time from t = [0,1].
+
+    Contains a function alpha_bar that takes an argument t and transforms it to the cumulative product of (1-beta) up
+    to that part of the diffusion process.
+
+
+    Args:
+        num_diffusion_timesteps (`int`): the number of betas to produce.
+        max_beta (`float`): the maximum beta to use; use values lower than 1 to
+                     prevent singularities.
+        alpha_transform_type (`str`, *optional*, default to `cosine`): the type of noise schedule for alpha_bar.
+                     Choose from `cosine` or `exp`
+
+    Returns:
+        betas (`np.ndarray`): the betas used by the scheduler to step the model outputs
+    """
+    if alpha_transform_type == "cosine":
+
+        def alpha_bar_fn(t):
+            return math.cos((t + 0.008) / 1.008 * math.pi / 2) ** 2
+            # return math.cos(t * math.pi / 2 * 0.95) ** 2
+
+    elif alpha_transform_type == "exp":
+
+        def alpha_bar_fn(t):
+            return math.exp(t * -12.0)
+
+    elif alpha_transform_type == "cauchy":
+        # µ + γ tan (π (0.5 - x))  γ = 1, µ = 3
+        # alpha^2 = 1-1/(exp(λ)+1)
+        def alpha_bar_fn(t, gamma=1, mu=3):
+            snr = mu + gamma * math.tan(math.pi * (0.5 - t) * 0.9)
+            return 1 - 1 / (math.exp(snr) + 1.1)
+
+    elif alpha_transform_type == "laplace":
+        # µ − bsgn(0.5 − t) log(1 − 2|t − 0.5|) µ = 0, b = 1
+        def alpha_bar_fn(t, mu=0, b=1):
+            snr = mu - b * math.copysign(1, 0.5 - t) * math.log(1 - 2 * abs(t - 0.5) * 0.98)
+            return 1 - 1 / (math.exp(snr) + 1.02)
+
+    else:
+        raise ValueError(f"Unsupported alpha_transform_type: {alpha_transform_type}")
+
+    betas = []
+    for i in range(num_diffusion_timesteps):
+        t1 = i / num_diffusion_timesteps
+        t2 = (i + 1) / num_diffusion_timesteps
+        betas.append(min(1 - alpha_bar_fn(t2) / alpha_bar_fn(t1), max_beta))
+    return torch.tensor(betas, dtype=torch.float32)
+
+
+# Copied from diffusers.schedulers.scheduling_ddim.rescale_zero_terminal_snr
+def rescale_zero_terminal_snr(betas):
+    """
+    Rescales betas to have zero terminal SNR Based on https://arxiv.org/pdf/2305.08891.pdf (Algorithm 1)
+
+
+    Args:
+        betas (`torch.Tensor`):
+            the betas that the scheduler is being initialized with.
+
+    Returns:
+        `torch.Tensor`: rescaled betas with zero terminal SNR
+    """
+    # Convert betas to alphas_bar_sqrt
+    alphas = 1.0 - betas
+    alphas_cumprod = torch.cumprod(alphas, dim=0)
+    alphas_bar_sqrt = alphas_cumprod.sqrt()
+
+    # Store old values.
+    alphas_bar_sqrt_0 = alphas_bar_sqrt[0].clone()
+    alphas_bar_sqrt_T = alphas_bar_sqrt[-1].clone()
+
+    # Shift so the last timestep is zero.
+    alphas_bar_sqrt -= alphas_bar_sqrt_T
+
+    # Scale so the first timestep is back to the old value.
+    alphas_bar_sqrt *= alphas_bar_sqrt_0 / (alphas_bar_sqrt_0 - alphas_bar_sqrt_T)
+
+    # Convert alphas_bar_sqrt to betas
+    alphas_bar = alphas_bar_sqrt**2  # Revert sqrt
+    alphas = alphas_bar[1:] / alphas_bar[:-1]  # Revert cumprod
+    alphas = torch.cat([alphas_bar[0:1], alphas])
+    betas = 1 - alphas
+
+    return betas
+
+class DPMSolverMultistepScheduler(SchedulerMixin, ConfigMixin):
+    """
+    `DPMSolverMultistepScheduler` is a fast dedicated high-order solver for diffusion ODEs.
+
+    This model inherits from [`SchedulerMixin`] and [`ConfigMixin`]. Check the superclass documentation for the generic
+    methods the library implements for all schedulers such as loading and saving.
+
+    Args:
+        num_train_timesteps (`int`, defaults to 1000):
+            The number of diffusion steps to train the model.
+        beta_start (`float`, defaults to 0.0001):
+            The starting `beta` value of inference.
+        beta_end (`float`, defaults to 0.02):
+            The final `beta` value.
+        beta_schedule (`str`, defaults to `"linear"`):
+            The beta schedule, a mapping from a beta range to a sequence of betas for stepping the model. Choose from
+            `linear`, `scaled_linear`, or `squaredcos_cap_v2`.
+        trained_betas (`np.ndarray`, *optional*):
+            Pass an array of betas directly to the constructor to bypass `beta_start` and `beta_end`.
+        solver_order (`int`, defaults to 2):
+            The DPMSolver order which can be `1` or `2` or `3`. It is recommended to use `solver_order=2` for guided
+            sampling, and `solver_order=3` for unconditional sampling.
+        prediction_type (`str`, defaults to `epsilon`, *optional*):
+            Prediction type of the scheduler function; can be `epsilon` (predicts the noise of the diffusion process),
+            `sample` (directly predicts the noisy sample`) or `v_prediction` (see section 2.4 of [Imagen
+            Video](https://imagen.research.google/video/paper.pdf) paper).
+        thresholding (`bool`, defaults to `False`):
+            Whether to use the "dynamic thresholding" method. This is unsuitable for latent-space diffusion models such
+            as Stable Diffusion.
+        dynamic_thresholding_ratio (`float`, defaults to 0.995):
+            The ratio for the dynamic thresholding method. Valid only when `thresholding=True`.
+        sample_max_value (`float`, defaults to 1.0):
+            The threshold value for dynamic thresholding. Valid only when `thresholding=True` and
+            `algorithm_type="dpmsolver++"`.
+        algorithm_type (`str`, defaults to `dpmsolver++`):
+            Algorithm type for the solver; can be `dpmsolver`, `dpmsolver++`, `sde-dpmsolver` or `sde-dpmsolver++`. The
+            `dpmsolver` type implements the algorithms in the [DPMSolver](https://huggingface.co/papers/2206.00927)
+            paper, and the `dpmsolver++` type implements the algorithms in the
+            [DPMSolver++](https://huggingface.co/papers/2211.01095) paper. It is recommended to use `dpmsolver++` or
+            `sde-dpmsolver++` with `solver_order=2` for guided sampling like in Stable Diffusion.
+        solver_type (`str`, defaults to `midpoint`):
+            Solver type for the second-order solver; can be `midpoint` or `heun`. The solver type slightly affects the
+            sample quality, especially for a small number of steps. It is recommended to use `midpoint` solvers.
+        lower_order_final (`bool`, defaults to `True`):
+            Whether to use lower-order solvers in the final steps. Only valid for < 15 inference steps. This can
+            stabilize the sampling of DPMSolver for steps < 15, especially for steps <= 10.
+        euler_at_final (`bool`, defaults to `False`):
+            Whether to use Euler's method in the final step. It is a trade-off between numerical stability and detail
+            richness. This can stabilize the sampling of the SDE variant of DPMSolver for small number of inference
+            steps, but sometimes may result in blurring.
+        use_karras_sigmas (`bool`, *optional*, defaults to `False`):
+            Whether to use Karras sigmas for step sizes in the noise schedule during the sampling process. If `True`,
+            the sigmas are determined according to a sequence of noise levels {σi}.
+        use_lu_lambdas (`bool`, *optional*, defaults to `False`):
+            Whether to use the uniform-logSNR for step sizes proposed by Lu's DPM-Solver in the noise schedule during
+            the sampling process. If `True`, the sigmas and time steps are determined according to a sequence of
+            `lambda(t)`.
+        final_sigmas_type (`str`, defaults to `"zero"`):
+            The final `sigma` value for the noise schedule during the sampling process. If `"sigma_min"`, the final
+            sigma is the same as the last sigma in the training schedule. If `zero`, the final sigma is set to 0.
+        lambda_min_clipped (`float`, defaults to `-inf`):
+            Clipping threshold for the minimum value of `lambda(t)` for numerical stability. This is critical for the
+            cosine (`squaredcos_cap_v2`) noise schedule.
+        variance_type (`str`, *optional*):
+            Set to "learned" or "learned_range" for diffusion models that predict variance. If set, the model's output
+            contains the predicted Gaussian variance.
+        timestep_spacing (`str`, defaults to `"linspace"`):
+            The way the timesteps should be scaled. Refer to Table 2 of the [Common Diffusion Noise Schedules and
+            Sample Steps are Flawed](https://huggingface.co/papers/2305.08891) for more information.
+        steps_offset (`int`, defaults to 0):
+            An offset added to the inference steps, as required by some model families.
+        rescale_betas_zero_snr (`bool`, defaults to `False`):
+            Whether to rescale the betas to have zero terminal SNR. This enables the model to generate very bright and
+            dark samples instead of limiting it to samples with medium brightness. Loosely related to
+            [`--offset_noise`](https://github.com/huggingface/diffusers/blob/74fd735eb073eb1d774b1ab4154a0876eb82f055/examples/dreambooth/train_dreambooth.py#L506).
+    """
+
+    _compatibles = [e.name for e in KarrasDiffusionSchedulers]
+    order = 1
+
+    @register_to_config
+    def __init__(
+        self,
+        num_train_timesteps: int = 1000,
+        beta_start: float = 0.0001,
+        beta_end: float = 0.02,
+        beta_schedule: str = "linear",
+        trained_betas: Optional[Union[np.ndarray, List[float]]] = None,
+        solver_order: int = 2,
+        prediction_type: str = "epsilon",
+        thresholding: bool = False,
+        dynamic_thresholding_ratio: float = 0.995,
+        sample_max_value: float = 1.0,
+        algorithm_type: str = "dpmsolver++",
+        solver_type: str = "midpoint",
+        lower_order_final: bool = True,
+        euler_at_final: bool = False,
+        use_karras_sigmas: Optional[bool] = False,
+        use_lu_lambdas: Optional[bool] = False,
+        final_sigmas_type: Optional[str] = "zero",  # "zero", "sigma_min"
+        lambda_min_clipped: float = -float("inf"),
+        variance_type: Optional[str] = None,
+        timestep_spacing: str = "linspace",
+        steps_offset: int = 0,
+        rescale_betas_zero_snr: bool = False,
+    ):
+        if algorithm_type in ["dpmsolver", "sde-dpmsolver"]:
+            deprecation_message = f"algorithm_type {algorithm_type} is deprecated and will be removed in a future version. Choose from `dpmsolver++` or `sde-dpmsolver++` instead"
+            deprecate("algorithm_types dpmsolver and sde-dpmsolver", "1.0.0", deprecation_message)
+
+        if trained_betas is not None:
+            self.betas = torch.tensor(trained_betas, dtype=torch.float32)
+        elif beta_schedule == "linear":
+            self.betas = torch.linspace(beta_start, beta_end, num_train_timesteps, dtype=torch.float32)
+        elif beta_schedule == "scaled_linear":
+            # this schedule is very specific to the latent diffusion model.
+            self.betas = torch.linspace(beta_start**0.5, beta_end**0.5, num_train_timesteps, dtype=torch.float32) ** 2
+        elif beta_schedule == "squaredcos_cap_v2" or beta_schedule == "cosine":
+            # Glide cosine schedule
+            self.betas = betas_for_alpha_bar(num_train_timesteps, alpha_transform_type="cosine")
+        elif beta_schedule == "cauchy":
+            self.betas = betas_for_alpha_bar(num_train_timesteps, alpha_transform_type="cauchy")
+        elif beta_schedule == "laplace":
+            self.betas = betas_for_alpha_bar(num_train_timesteps, alpha_transform_type="laplace")
+        else:
+            raise NotImplementedError(f"{beta_schedule} is not implemented for {self.__class__}")
+
+        if rescale_betas_zero_snr:
+            self.betas = rescale_zero_terminal_snr(self.betas)
+
+        self.alphas = 1.0 - self.betas
+        self.alphas_cumprod = torch.cumprod(self.alphas, dim=0)
+
+        if rescale_betas_zero_snr:
+            # Close to 0 without being 0 so first sigma is not inf
+            # FP16 smallest positive subnormal works well here
+            self.alphas_cumprod[-1] = 2**-24
+
+        # Currently we only support VP-type noise schedule
+        self.alpha_t = torch.sqrt(self.alphas_cumprod)
+        self.sigma_t = torch.sqrt(1 - self.alphas_cumprod)
+        self.lambda_t = torch.log(self.alpha_t) - torch.log(self.sigma_t)
+        self.sigmas = ((1 - self.alphas_cumprod) / self.alphas_cumprod) ** 0.5
+
+        # standard deviation of the initial noise distribution
+        self.init_noise_sigma = 1.0
+
+        # settings for DPM-Solver
+        if algorithm_type not in ["dpmsolver", "dpmsolver++", "sde-dpmsolver", "sde-dpmsolver++"]:
+            if algorithm_type == "deis":
+                self.register_to_config(algorithm_type="dpmsolver++")
+            else:
+                raise NotImplementedError(f"{algorithm_type} is not implemented for {self.__class__}")
+
+        if solver_type not in ["midpoint", "heun"]:
+            if solver_type in ["logrho", "bh1", "bh2"]:
+                self.register_to_config(solver_type="midpoint")
+            else:
+                raise NotImplementedError(f"{solver_type} is not implemented for {self.__class__}")
+
+        if algorithm_type not in ["dpmsolver++", "sde-dpmsolver++"] and final_sigmas_type == "zero":
+            raise ValueError(
+                f"`final_sigmas_type` {final_sigmas_type} is not supported for `algorithm_type` {algorithm_type}. Please choose `sigma_min` instead."
+            )
+
+        # setable values
+        self.num_inference_steps = None
+        timesteps = np.linspace(0, num_train_timesteps - 1, num_train_timesteps, dtype=np.float32)[::-1].copy()
+        self.timesteps = torch.from_numpy(timesteps)
+        self.model_outputs = [None] * solver_order
+        self.lower_order_nums = 0
+        self._step_index = None
+        self._begin_index = None
+        self.sigmas = self.sigmas.to("cpu")  # to avoid too much CPU/GPU communication
+
+    @property
+    def step_index(self):
+        """
+        The index counter for current timestep. It will increase 1 after each scheduler step.
+        """
+        return self._step_index
+
+    @property
+    def begin_index(self):
+        """
+        The index for the first timestep. It should be set from pipeline with `set_begin_index` method.
+        """
+        return self._begin_index
+
+    def set_begin_index(self, begin_index: int = 0):
+        """
+        Sets the begin index for the scheduler. This function should be run from pipeline before the inference.
+
+        Args:
+            begin_index (`int`):
+                The begin index for the scheduler.
+        """
+        self._begin_index = begin_index
+
+    def set_timesteps(
+        self,
+        num_inference_steps: int = None,
+        device: Union[str, torch.device] = None,
+        timesteps: Optional[List[int]] = None,
+    ):
+        """
+        Sets the discrete timesteps used for the diffusion chain (to be run before inference).
+
+        Args:
+            num_inference_steps (`int`):
+                The number of diffusion steps used when generating samples with a pre-trained model.
+            device (`str` or `torch.device`, *optional*):
+                The device to which the timesteps should be moved to. If `None`, the timesteps are not moved.
+            timesteps (`List[int]`, *optional*):
+                Custom timesteps used to support arbitrary timesteps schedule. If `None`, timesteps will be generated
+                based on the `timestep_spacing` attribute. If `timesteps` is passed, `num_inference_steps` and `sigmas`
+                must be `None`, and `timestep_spacing` attribute will be ignored.
+        """
+        if num_inference_steps is None and timesteps is None:
+            raise ValueError("Must pass exactly one of `num_inference_steps` or `timesteps`.")
+        if num_inference_steps is not None and timesteps is not None:
+            raise ValueError("Can only pass one of `num_inference_steps` or `custom_timesteps`.")
+        if timesteps is not None and self.config.use_karras_sigmas:
+            raise ValueError("Cannot use `timesteps` with `config.use_karras_sigmas = True`")
+        if timesteps is not None and self.config.use_lu_lambdas:
+            raise ValueError("Cannot use `timesteps` with `config.use_lu_lambdas = True`")
+
+        if timesteps is not None:
+            timesteps = np.array(timesteps).astype(np.int64)
+        else:
+            # Clipping the minimum of all lambda(t) for numerical stability.
+            # This is critical for cosine (squaredcos_cap_v2) noise schedule.
+            clipped_idx = torch.searchsorted(torch.flip(self.lambda_t, [0]), self.config.lambda_min_clipped)
+            last_timestep = ((self.config.num_train_timesteps - clipped_idx).numpy()).item()
+
+            # "linspace", "leading", "trailing" corresponds to annotation of Table 2. of https://arxiv.org/abs/2305.08891
+            if self.config.timestep_spacing == "linspace":
+                timesteps = (
+                    np.linspace(0, last_timestep - 1, num_inference_steps + 1)
+                    .round()[::-1][:-1]
+                    .copy()
+                    .astype(np.int64)
+                )
+            elif self.config.timestep_spacing == "leading":
+                step_ratio = last_timestep // (num_inference_steps + 1)
+                # creates integer timesteps by multiplying by ratio
+                # casting to int to avoid issues when num_inference_step is power of 3
+                timesteps = (
+                    (np.arange(0, num_inference_steps + 1) * step_ratio).round()[::-1][:-1].copy().astype(np.int64)
+                )
+                timesteps += self.config.steps_offset
+            elif self.config.timestep_spacing == "trailing":
+                step_ratio = self.config.num_train_timesteps / num_inference_steps
+                # creates integer timesteps by multiplying by ratio
+                # casting to int to avoid issues when num_inference_step is power of 3
+                timesteps = np.arange(last_timestep, 0, -step_ratio).round().copy().astype(np.int64)
+                timesteps -= 1
+            else:
+                raise ValueError(
+                    f"{self.config.timestep_spacing} is not supported. Please make sure to choose one of 'linspace', 'leading' or 'trailing'."
+                )
+
+        sigmas = np.array(((1 - self.alphas_cumprod) / self.alphas_cumprod) ** 0.5)
+        log_sigmas = np.log(sigmas)
+
+        if self.config.use_karras_sigmas:
+            sigmas = np.flip(sigmas).copy()
+            sigmas = self._convert_to_karras(in_sigmas=sigmas, num_inference_steps=num_inference_steps)
+            timesteps = np.array([self._sigma_to_t(sigma, log_sigmas) for sigma in sigmas]).round()
+        elif self.config.use_lu_lambdas:
+            lambdas = np.flip(log_sigmas.copy())
+            lambdas = self._convert_to_lu(in_lambdas=lambdas, num_inference_steps=num_inference_steps)
+            sigmas = np.exp(lambdas)
+            timesteps = np.array([self._sigma_to_t(sigma, log_sigmas) for sigma in sigmas]).round()
+        else:
+            sigmas = np.interp(timesteps, np.arange(0, len(sigmas)), sigmas)
+
+        if self.config.final_sigmas_type == "sigma_min":
+            sigma_last = ((1 - self.alphas_cumprod[0]) / self.alphas_cumprod[0]) ** 0.5
+        elif self.config.final_sigmas_type == "zero":
+            sigma_last = 0
+        else:
+            raise ValueError(
+                f"`final_sigmas_type` must be one of 'zero', or 'sigma_min', but got {self.config.final_sigmas_type}"
+            )
+
+        sigmas = np.concatenate([sigmas, [sigma_last]]).astype(np.float32)
+
+        self.sigmas = torch.from_numpy(sigmas)
+        self.timesteps = torch.from_numpy(timesteps).to(device=device, dtype=torch.int64)
+
+        self.num_inference_steps = len(timesteps)
+
+        self.model_outputs = [
+            None,
+        ] * self.config.solver_order
+        self.lower_order_nums = 0
+
+        # add an index counter for schedulers that allow duplicated timesteps
+        self._step_index = None
+        self._begin_index = None
+        self.sigmas = self.sigmas.to("cpu")  # to avoid too much CPU/GPU communication
+
+    # Copied from diffusers.schedulers.scheduling_ddpm.DDPMScheduler._threshold_sample
+    def _threshold_sample(self, sample: torch.Tensor) -> torch.Tensor:
+        """
+        "Dynamic thresholding: At each sampling step we set s to a certain percentile absolute pixel value in xt0 (the
+        prediction of x_0 at timestep t), and if s > 1, then we threshold xt0 to the range [-s, s] and then divide by
+        s. Dynamic thresholding pushes saturated pixels (those near -1 and 1) inwards, thereby actively preventing
+        pixels from saturation at each step. We find that dynamic thresholding results in significantly better
+        photorealism as well as better image-text alignment, especially when using very large guidance weights."
+
+        https://arxiv.org/abs/2205.11487
+        """
+        dtype = sample.dtype
+        batch_size, channels, *remaining_dims = sample.shape
+
+        if dtype not in (torch.float32, torch.float64):
+            sample = sample.float()  # upcast for quantile calculation, and clamp not implemented for cpu half
+
+        # Flatten sample for doing quantile calculation along each image
+        sample = sample.reshape(batch_size, channels * np.prod(remaining_dims))
+
+        abs_sample = sample.abs()  # "a certain percentile absolute pixel value"
+
+        s = torch.quantile(abs_sample, self.config.dynamic_thresholding_ratio, dim=1)
+        s = torch.clamp(
+            s, min=1, max=self.config.sample_max_value
+        )  # When clamped to min=1, equivalent to standard clipping to [-1, 1]
+        s = s.unsqueeze(1)  # (batch_size, 1) because clamp will broadcast along dim=0
+        sample = torch.clamp(sample, -s, s) / s  # "we threshold xt0 to the range [-s, s] and then divide by s"
+
+        sample = sample.reshape(batch_size, channels, *remaining_dims)
+        sample = sample.to(dtype)
+
+        return sample
+
+    # Copied from diffusers.schedulers.scheduling_euler_discrete.EulerDiscreteScheduler._sigma_to_t
+    def _sigma_to_t(self, sigma, log_sigmas):
+        # get log sigma
+        log_sigma = np.log(np.maximum(sigma, 1e-10))
+
+        # get distribution
+        dists = log_sigma - log_sigmas[:, np.newaxis]
+
+        # get sigmas range
+        low_idx = np.cumsum((dists >= 0), axis=0).argmax(axis=0).clip(max=log_sigmas.shape[0] - 2)
+        high_idx = low_idx + 1
+
+        low = log_sigmas[low_idx]
+        high = log_sigmas[high_idx]
+
+        # interpolate sigmas
+        w = (low - log_sigma) / (low - high)
+        w = np.clip(w, 0, 1)
+
+        # transform interpolation to time range
+        t = (1 - w) * low_idx + w * high_idx
+        t = t.reshape(sigma.shape)
+        return t
+
+    def _sigma_to_alpha_sigma_t(self, sigma):
+        alpha_t = 1 / ((sigma**2 + 1) ** 0.5)
+        sigma_t = sigma * alpha_t
+
+        return alpha_t, sigma_t
+
+    # Copied from diffusers.schedulers.scheduling_euler_discrete.EulerDiscreteScheduler._convert_to_karras
+    def _convert_to_karras(self, in_sigmas: torch.Tensor, num_inference_steps) -> torch.Tensor:
+        """Constructs the noise schedule of Karras et al. (2022)."""
+
+        # Hack to make sure that other schedulers which copy this function don't break
+        # TODO: Add this logic to the other schedulers
+        if hasattr(self.config, "sigma_min"):
+            sigma_min = self.config.sigma_min
+        else:
+            sigma_min = None
+
+        if hasattr(self.config, "sigma_max"):
+            sigma_max = self.config.sigma_max
+        else:
+            sigma_max = None
+
+        sigma_min = sigma_min if sigma_min is not None else in_sigmas[-1].item()
+        sigma_max = sigma_max if sigma_max is not None else in_sigmas[0].item()
+
+        rho = 7.0  # 7.0 is the value used in the paper
+        ramp = np.linspace(0, 1, num_inference_steps)
+        min_inv_rho = sigma_min ** (1 / rho)
+        max_inv_rho = sigma_max ** (1 / rho)
+        sigmas = (max_inv_rho + ramp * (min_inv_rho - max_inv_rho)) ** rho
+        return sigmas
+
+    def _convert_to_lu(self, in_lambdas: torch.Tensor, num_inference_steps) -> torch.Tensor:
+        """Constructs the noise schedule of Lu et al. (2022)."""
+
+        lambda_min: float = in_lambdas[-1].item()
+        lambda_max: float = in_lambdas[0].item()
+
+        rho = 1.0  # 1.0 is the value used in the paper
+        ramp = np.linspace(0, 1, num_inference_steps)
+        min_inv_rho = lambda_min ** (1 / rho)
+        max_inv_rho = lambda_max ** (1 / rho)
+        lambdas = (max_inv_rho + ramp * (min_inv_rho - max_inv_rho)) ** rho
+        return lambdas
+
+    def convert_model_output(
+        self,
+        model_output: torch.Tensor,
+        *args,
+        sample: torch.Tensor = None,
+        **kwargs,
+    ) -> torch.Tensor:
+        """
+        Convert the model output to the corresponding type the DPMSolver/DPMSolver++ algorithm needs. DPM-Solver is
+        designed to discretize an integral of the noise prediction model, and DPM-Solver++ is designed to discretize an
+        integral of the data prediction model.
+
+        <Tip>
+
+        The algorithm and model type are decoupled. You can use either DPMSolver or DPMSolver++ for both noise
+        prediction and data prediction models.
+
+        </Tip>
+
+        Args:
+            model_output (`torch.Tensor`):
+                The direct output from the learned diffusion model.
+            sample (`torch.Tensor`):
+                A current instance of a sample created by the diffusion process.
+
+        Returns:
+            `torch.Tensor`:
+                The converted model output.
+        """
+        timestep = args[0] if len(args) > 0 else kwargs.pop("timestep", None)
+        if sample is None:
+            if len(args) > 1:
+                sample = args[1]
+            else:
+                raise ValueError("missing `sample` as a required keyward argument")
+        if timestep is not None:
+            deprecate(
+                "timesteps",
+                "1.0.0",
+                "Passing `timesteps` is deprecated and has no effect as model output conversion is now handled via an internal counter `self.step_index`",
+            )
+
+        # DPM-Solver++ needs to solve an integral of the data prediction model.
+        if self.config.algorithm_type in ["dpmsolver++", "sde-dpmsolver++"]:
+            if self.config.prediction_type == "epsilon":
+                # DPM-Solver and DPM-Solver++ only need the "mean" output.
+                if self.config.variance_type in ["learned", "learned_range"]:
+                    model_output = model_output[:, :3]
+                sigma = self.sigmas[self.step_index]
+                alpha_t, sigma_t = self._sigma_to_alpha_sigma_t(sigma)
+                x0_pred = (sample - sigma_t * model_output) / alpha_t
+            elif self.config.prediction_type == "sample":
+                x0_pred = model_output
+            elif self.config.prediction_type == "v_prediction":
+                sigma = self.sigmas[self.step_index]
+                alpha_t, sigma_t = self._sigma_to_alpha_sigma_t(sigma)
+                x0_pred = alpha_t * sample - sigma_t * model_output
+            else:
+                raise ValueError(
+                    f"prediction_type given as {self.config.prediction_type} must be one of `epsilon`, `sample`, or"
+                    " `v_prediction` for the DPMSolverMultistepScheduler."
+                )
+
+            if self.config.thresholding:
+                x0_pred = self._threshold_sample(x0_pred)
+
+            return x0_pred
+
+        # DPM-Solver needs to solve an integral of the noise prediction model.
+        elif self.config.algorithm_type in ["dpmsolver", "sde-dpmsolver"]:
+            if self.config.prediction_type == "epsilon":
+                # DPM-Solver and DPM-Solver++ only need the "mean" output.
+                if self.config.variance_type in ["learned", "learned_range"]:
+                    epsilon = model_output[:, :3]
+                else:
+                    epsilon = model_output
+            elif self.config.prediction_type == "sample":
+                sigma = self.sigmas[self.step_index]
+                alpha_t, sigma_t = self._sigma_to_alpha_sigma_t(sigma)
+                epsilon = (sample - alpha_t * model_output) / sigma_t
+            elif self.config.prediction_type == "v_prediction":
+                sigma = self.sigmas[self.step_index]
+                alpha_t, sigma_t = self._sigma_to_alpha_sigma_t(sigma)
+                epsilon = alpha_t * model_output + sigma_t * sample
+            else:
+                raise ValueError(
+                    f"prediction_type given as {self.config.prediction_type} must be one of `epsilon`, `sample`, or"
+                    " `v_prediction` for the DPMSolverMultistepScheduler."
+                )
+
+            if self.config.thresholding:
+                sigma = self.sigmas[self.step_index]
+                alpha_t, sigma_t = self._sigma_to_alpha_sigma_t(sigma)
+                x0_pred = (sample - sigma_t * epsilon) / alpha_t
+                x0_pred = self._threshold_sample(x0_pred)
+                epsilon = (sample - alpha_t * x0_pred) / sigma_t
+
+            return epsilon
+
+    def dpm_solver_first_order_update(
+        self,
+        model_output: torch.Tensor,
+        *args,
+        sample: torch.Tensor = None,
+        noise: Optional[torch.Tensor] = None,
+        **kwargs,
+    ) -> torch.Tensor:
+        """
+        One step for the first-order DPMSolver (equivalent to DDIM).
+
+        Args:
+            model_output (`torch.Tensor`):
+                The direct output from the learned diffusion model.
+            sample (`torch.Tensor`):
+                A current instance of a sample created by the diffusion process.
+
+        Returns:
+            `torch.Tensor`:
+                The sample tensor at the previous timestep.
+        """
+        timestep = args[0] if len(args) > 0 else kwargs.pop("timestep", None)
+        prev_timestep = args[1] if len(args) > 1 else kwargs.pop("prev_timestep", None)
+        if sample is None:
+            if len(args) > 2:
+                sample = args[2]
+            else:
+                raise ValueError(" missing `sample` as a required keyward argument")
+        if timestep is not None:
+            deprecate(
+                "timesteps",
+                "1.0.0",
+                "Passing `timesteps` is deprecated and has no effect as model output conversion is now handled via an internal counter `self.step_index`",
+            )
+
+        if prev_timestep is not None:
+            deprecate(
+                "prev_timestep",
+                "1.0.0",
+                "Passing `prev_timestep` is deprecated and has no effect as model output conversion is now handled via an internal counter `self.step_index`",
+            )
+
+        sigma_t, sigma_s = self.sigmas[self.step_index + 1], self.sigmas[self.step_index]
+        alpha_t, sigma_t = self._sigma_to_alpha_sigma_t(sigma_t)
+        alpha_s, sigma_s = self._sigma_to_alpha_sigma_t(sigma_s)
+        lambda_t = torch.log(alpha_t) - torch.log(sigma_t)
+        lambda_s = torch.log(alpha_s) - torch.log(sigma_s)
+
+        h = lambda_t - lambda_s
+        if self.config.algorithm_type == "dpmsolver++":
+            x_t = (sigma_t / sigma_s) * sample - (alpha_t * (torch.exp(-h) - 1.0)) * model_output
+        elif self.config.algorithm_type == "dpmsolver":
+            x_t = (alpha_t / alpha_s) * sample - (sigma_t * (torch.exp(h) - 1.0)) * model_output
+        elif self.config.algorithm_type == "sde-dpmsolver++":
+            assert noise is not None
+            x_t = (
+                (sigma_t / sigma_s * torch.exp(-h)) * sample
+                + (alpha_t * (1 - torch.exp(-2.0 * h))) * model_output
+                + sigma_t * torch.sqrt(1.0 - torch.exp(-2 * h)) * noise
+            )
+        elif self.config.algorithm_type == "sde-dpmsolver":
+            assert noise is not None
+            x_t = (
+                (alpha_t / alpha_s) * sample
+                - 2.0 * (sigma_t * (torch.exp(h) - 1.0)) * model_output
+                + sigma_t * torch.sqrt(torch.exp(2 * h) - 1.0) * noise
+            )
+        return x_t
+
+    def multistep_dpm_solver_second_order_update(
+        self,
+        model_output_list: List[torch.Tensor],
+        *args,
+        sample: torch.Tensor = None,
+        noise: Optional[torch.Tensor] = None,
+        **kwargs,
+    ) -> torch.Tensor:
+        """
+        One step for the second-order multistep DPMSolver.
+
+        Args:
+            model_output_list (`List[torch.Tensor]`):
+                The direct outputs from learned diffusion model at current and latter timesteps.
+            sample (`torch.Tensor`):
+                A current instance of a sample created by the diffusion process.
+
+        Returns:
+            `torch.Tensor`:
+                The sample tensor at the previous timestep.
+        """
+        timestep_list = args[0] if len(args) > 0 else kwargs.pop("timestep_list", None)
+        prev_timestep = args[1] if len(args) > 1 else kwargs.pop("prev_timestep", None)
+        if sample is None:
+            if len(args) > 2:
+                sample = args[2]
+            else:
+                raise ValueError(" missing `sample` as a required keyward argument")
+        if timestep_list is not None:
+            deprecate(
+                "timestep_list",
+                "1.0.0",
+                "Passing `timestep_list` is deprecated and has no effect as model output conversion is now handled via an internal counter `self.step_index`",
+            )
+
+        if prev_timestep is not None:
+            deprecate(
+                "prev_timestep",
+                "1.0.0",
+                "Passing `prev_timestep` is deprecated and has no effect as model output conversion is now handled via an internal counter `self.step_index`",
+            )
+
+        sigma_t, sigma_s0, sigma_s1 = (
+            self.sigmas[self.step_index + 1],
+            self.sigmas[self.step_index],
+            self.sigmas[self.step_index - 1],
+        )
+
+        alpha_t, sigma_t = self._sigma_to_alpha_sigma_t(sigma_t)
+        alpha_s0, sigma_s0 = self._sigma_to_alpha_sigma_t(sigma_s0)
+        alpha_s1, sigma_s1 = self._sigma_to_alpha_sigma_t(sigma_s1)
+
+        lambda_t = torch.log(alpha_t) - torch.log(sigma_t)
+        lambda_s0 = torch.log(alpha_s0) - torch.log(sigma_s0)
+        lambda_s1 = torch.log(alpha_s1) - torch.log(sigma_s1)
+
+        m0, m1 = model_output_list[-1], model_output_list[-2]
+
+        h, h_0 = lambda_t - lambda_s0, lambda_s0 - lambda_s1
+        r0 = h_0 / h
+        D0, D1 = m0, (1.0 / r0) * (m0 - m1)
+        if self.config.algorithm_type == "dpmsolver++":
+            # See https://arxiv.org/abs/2211.01095 for detailed derivations
+            if self.config.solver_type == "midpoint":
+                x_t = (
+                    (sigma_t / sigma_s0) * sample
+                    - (alpha_t * (torch.exp(-h) - 1.0)) * D0
+                    - 0.5 * (alpha_t * (torch.exp(-h) - 1.0)) * D1
+                )
+            elif self.config.solver_type == "heun":
+                x_t = (
+                    (sigma_t / sigma_s0) * sample
+                    - (alpha_t * (torch.exp(-h) - 1.0)) * D0
+                    + (alpha_t * ((torch.exp(-h) - 1.0) / h + 1.0)) * D1
+                )
+        elif self.config.algorithm_type == "dpmsolver":
+            # See https://arxiv.org/abs/2206.00927 for detailed derivations
+            if self.config.solver_type == "midpoint":
+                x_t = (
+                    (alpha_t / alpha_s0) * sample
+                    - (sigma_t * (torch.exp(h) - 1.0)) * D0
+                    - 0.5 * (sigma_t * (torch.exp(h) - 1.0)) * D1
+                )
+            elif self.config.solver_type == "heun":
+                x_t = (
+                    (alpha_t / alpha_s0) * sample
+                    - (sigma_t * (torch.exp(h) - 1.0)) * D0
+                    - (sigma_t * ((torch.exp(h) - 1.0) / h - 1.0)) * D1
+                )
+        elif self.config.algorithm_type == "sde-dpmsolver++":
+            assert noise is not None
+            if self.config.solver_type == "midpoint":
+                x_t = (
+                    (sigma_t / sigma_s0 * torch.exp(-h)) * sample
+                    + (alpha_t * (1 - torch.exp(-2.0 * h))) * D0
+                    + 0.5 * (alpha_t * (1 - torch.exp(-2.0 * h))) * D1
+                    + sigma_t * torch.sqrt(1.0 - torch.exp(-2 * h)) * noise
+                )
+            elif self.config.solver_type == "heun":
+                x_t = (
+                    (sigma_t / sigma_s0 * torch.exp(-h)) * sample
+                    + (alpha_t * (1 - torch.exp(-2.0 * h))) * D0
+                    + (alpha_t * ((1.0 - torch.exp(-2.0 * h)) / (-2.0 * h) + 1.0)) * D1
+                    + sigma_t * torch.sqrt(1.0 - torch.exp(-2 * h)) * noise
+                )
+        elif self.config.algorithm_type == "sde-dpmsolver":
+            assert noise is not None
+            if self.config.solver_type == "midpoint":
+                x_t = (
+                    (alpha_t / alpha_s0) * sample
+                    - 2.0 * (sigma_t * (torch.exp(h) - 1.0)) * D0
+                    - (sigma_t * (torch.exp(h) - 1.0)) * D1
+                    + sigma_t * torch.sqrt(torch.exp(2 * h) - 1.0) * noise
+                )
+            elif self.config.solver_type == "heun":
+                x_t = (
+                    (alpha_t / alpha_s0) * sample
+                    - 2.0 * (sigma_t * (torch.exp(h) - 1.0)) * D0
+                    - 2.0 * (sigma_t * ((torch.exp(h) - 1.0) / h - 1.0)) * D1
+                    + sigma_t * torch.sqrt(torch.exp(2 * h) - 1.0) * noise
+                )
+        return x_t
+
+    def multistep_dpm_solver_third_order_update(
+        self,
+        model_output_list: List[torch.Tensor],
+        *args,
+        sample: torch.Tensor = None,
+        **kwargs,
+    ) -> torch.Tensor:
+        """
+        One step for the third-order multistep DPMSolver.
+
+        Args:
+            model_output_list (`List[torch.Tensor]`):
+                The direct outputs from learned diffusion model at current and latter timesteps.
+            sample (`torch.Tensor`):
+                A current instance of a sample created by diffusion process.
+
+        Returns:
+            `torch.Tensor`:
+                The sample tensor at the previous timestep.
+        """
+
+        timestep_list = args[0] if len(args) > 0 else kwargs.pop("timestep_list", None)
+        prev_timestep = args[1] if len(args) > 1 else kwargs.pop("prev_timestep", None)
+        if sample is None:
+            if len(args) > 2:
+                sample = args[2]
+            else:
+                raise ValueError(" missing`sample` as a required keyward argument")
+        if timestep_list is not None:
+            deprecate(
+                "timestep_list",
+                "1.0.0",
+                "Passing `timestep_list` is deprecated and has no effect as model output conversion is now handled via an internal counter `self.step_index`",
+            )
+
+        if prev_timestep is not None:
+            deprecate(
+                "prev_timestep",
+                "1.0.0",
+                "Passing `prev_timestep` is deprecated and has no effect as model output conversion is now handled via an internal counter `self.step_index`",
+            )
+
+        sigma_t, sigma_s0, sigma_s1, sigma_s2 = (
+            self.sigmas[self.step_index + 1],
+            self.sigmas[self.step_index],
+            self.sigmas[self.step_index - 1],
+            self.sigmas[self.step_index - 2],
+        )
+
+        alpha_t, sigma_t = self._sigma_to_alpha_sigma_t(sigma_t)
+        alpha_s0, sigma_s0 = self._sigma_to_alpha_sigma_t(sigma_s0)
+        alpha_s1, sigma_s1 = self._sigma_to_alpha_sigma_t(sigma_s1)
+        alpha_s2, sigma_s2 = self._sigma_to_alpha_sigma_t(sigma_s2)
+
+        lambda_t = torch.log(alpha_t) - torch.log(sigma_t)
+        lambda_s0 = torch.log(alpha_s0) - torch.log(sigma_s0)
+        lambda_s1 = torch.log(alpha_s1) - torch.log(sigma_s1)
+        lambda_s2 = torch.log(alpha_s2) - torch.log(sigma_s2)
+
+        m0, m1, m2 = model_output_list[-1], model_output_list[-2], model_output_list[-3]
+
+        h, h_0, h_1 = lambda_t - lambda_s0, lambda_s0 - lambda_s1, lambda_s1 - lambda_s2
+        r0, r1 = h_0 / h, h_1 / h
+        D0 = m0
+        D1_0, D1_1 = (1.0 / r0) * (m0 - m1), (1.0 / r1) * (m1 - m2)
+        D1 = D1_0 + (r0 / (r0 + r1)) * (D1_0 - D1_1)
+        D2 = (1.0 / (r0 + r1)) * (D1_0 - D1_1)
+        if self.config.algorithm_type == "dpmsolver++":
+            # See https://arxiv.org/abs/2206.00927 for detailed derivations
+            x_t = (
+                (sigma_t / sigma_s0) * sample
+                - (alpha_t * (torch.exp(-h) - 1.0)) * D0
+                + (alpha_t * ((torch.exp(-h) - 1.0) / h + 1.0)) * D1
+                - (alpha_t * ((torch.exp(-h) - 1.0 + h) / h**2 - 0.5)) * D2
+            )
+        elif self.config.algorithm_type == "dpmsolver":
+            # See https://arxiv.org/abs/2206.00927 for detailed derivations
+            x_t = (
+                (alpha_t / alpha_s0) * sample
+                - (sigma_t * (torch.exp(h) - 1.0)) * D0
+                - (sigma_t * ((torch.exp(h) - 1.0) / h - 1.0)) * D1
+                - (sigma_t * ((torch.exp(h) - 1.0 - h) / h**2 - 0.5)) * D2
+            )
+        return x_t
+
+    def index_for_timestep(self, timestep, schedule_timesteps=None):
+        if schedule_timesteps is None:
+            schedule_timesteps = self.timesteps
+
+        index_candidates = (schedule_timesteps == timestep).nonzero()
+
+        if len(index_candidates) == 0:
+            step_index = len(self.timesteps) - 1
+        # The sigma index that is taken for the **very** first `step`
+        # is always the second index (or the last index if there is only 1)
+        # This way we can ensure we don't accidentally skip a sigma in
+        # case we start in the middle of the denoising schedule (e.g. for image-to-image)
+        elif len(index_candidates) > 1:
+            step_index = index_candidates[1].item()
+        else:
+            step_index = index_candidates[0].item()
+
+        return step_index
+
+    def _init_step_index(self, timestep):
+        """
+        Initialize the step_index counter for the scheduler.
+        """
+
+        if self.begin_index is None:
+            if isinstance(timestep, torch.Tensor):
+                timestep = timestep.to(self.timesteps.device)
+            self._step_index = self.index_for_timestep(timestep)
+        else:
+            self._step_index = self._begin_index
+
+    def step(
+        self,
+        model_output: torch.Tensor,
+        timestep: int,
+        sample: torch.Tensor,
+        generator=None,
+        variance_noise: Optional[torch.Tensor] = None,
+        return_dict: bool = True,
+    ) -> Union[SchedulerOutput, Tuple]:
+        """
+        Predict the sample from the previous timestep by reversing the SDE. This function propagates the sample with
+        the multistep DPMSolver.
+
+        Args:
+            model_output (`torch.Tensor`):
+                The direct output from learned diffusion model.
+            timestep (`int`):
+                The current discrete timestep in the diffusion chain.
+            sample (`torch.Tensor`):
+                A current instance of a sample created by the diffusion process.
+            generator (`torch.Generator`, *optional*):
+                A random number generator.
+            variance_noise (`torch.Tensor`):
+                Alternative to generating noise with `generator` by directly providing the noise for the variance
+                itself. Useful for methods such as [`LEdits++`].
+            return_dict (`bool`):
+                Whether or not to return a [`~schedulers.scheduling_utils.SchedulerOutput`] or `tuple`.
+
+        Returns:
+            [`~schedulers.scheduling_utils.SchedulerOutput`] or `tuple`:
+                If return_dict is `True`, [`~schedulers.scheduling_utils.SchedulerOutput`] is returned, otherwise a
+                tuple is returned where the first element is the sample tensor.
+
+        """
+        if self.num_inference_steps is None:
+            raise ValueError(
+                "Number of inference steps is 'None', you need to run 'set_timesteps' after creating the scheduler"
+            )
+
+        if self.step_index is None:
+            self._init_step_index(timestep)
+
+        # Improve numerical stability for small number of steps
+        lower_order_final = (self.step_index == len(self.timesteps) - 1) and (
+            self.config.euler_at_final
+            or (self.config.lower_order_final and len(self.timesteps) < 15)
+            or self.config.final_sigmas_type == "zero"
+        )
+        lower_order_second = (
+            (self.step_index == len(self.timesteps) - 2) and self.config.lower_order_final and len(self.timesteps) < 15
+        )
+
+        model_output = self.convert_model_output(model_output, sample=sample)
+        for i in range(self.config.solver_order - 1):
+            self.model_outputs[i] = self.model_outputs[i + 1]
+        self.model_outputs[-1] = model_output
+
+        # Upcast to avoid precision issues when computing prev_sample
+        sample = sample.to(torch.float32)
+        if self.config.algorithm_type in ["sde-dpmsolver", "sde-dpmsolver++"] and variance_noise is None:
+            noise = randn_tensor(
+                model_output.shape, generator=generator, device=model_output.device, dtype=torch.float32
+            )
+        elif self.config.algorithm_type in ["sde-dpmsolver", "sde-dpmsolver++"]:
+            noise = variance_noise.to(device=model_output.device, dtype=torch.float32)
+        else:
+            noise = None
+
+        if self.config.solver_order == 1 or self.lower_order_nums < 1 or lower_order_final:
+            prev_sample = self.dpm_solver_first_order_update(model_output, sample=sample, noise=noise)
+        elif self.config.solver_order == 2 or self.lower_order_nums < 2 or lower_order_second:
+            prev_sample = self.multistep_dpm_solver_second_order_update(self.model_outputs, sample=sample, noise=noise)
+        else:
+            prev_sample = self.multistep_dpm_solver_third_order_update(self.model_outputs, sample=sample)
+
+        if self.lower_order_nums < self.config.solver_order:
+            self.lower_order_nums += 1
+
+        # Cast sample back to expected dtype
+        prev_sample = prev_sample.to(model_output.dtype)
+
+        # upon completion increase step index by one
+        self._step_index += 1
+
+        if not return_dict:
+            return (prev_sample,)
+
+        return SchedulerOutput(prev_sample=prev_sample)
+
+    def add_noise(
+        self,
+        original_samples: torch.Tensor,
+        noise: torch.Tensor,
+        timesteps: torch.IntTensor,
+    ) -> torch.Tensor:
+        # Make sure sigmas and timesteps have the same device and dtype as original_samples
+        # alpha_t = self.alpha_t.to(device=original_samples.device, dtype=original_samples.dtype)
+        # sigma_t = self.sigma_t.to(device=original_samples.device, dtype=original_samples.dtype)
+        alpha_t = self.alpha_t.to(original_samples.device).to(original_samples.dtype)
+        sigma_t = self.sigma_t.to(original_samples.device).to(original_samples.dtype)
+        timesteps = timesteps.to(original_samples.device)
+        alpha_t = alpha_t[timesteps].flatten()
+        while len(alpha_t.shape) < len(original_samples.shape):
+            alpha_t = alpha_t.unsqueeze(-1)
+
+        sigma_t = sigma_t[timesteps].flatten()
+        while len(sigma_t.shape) < len(original_samples.shape):
+            sigma_t = sigma_t.unsqueeze(-1)
+        noisy_samples = alpha_t * original_samples + sigma_t * noise
+        return noisy_samples
+    
+    def get_velocity(self, original_samples: torch.Tensor, noise: torch.Tensor, timesteps: torch.IntTensor) -> torch.Tensor:
+        # alpha_t = self.alpha_t.to(device=original_samples.device, dtype=original_samples.dtype)
+        # sigma_t = self.sigma_t.to(device=original_samples.device, dtype=original_samples.dtype)
+        alpha_t = self.alpha_t.to(original_samples.device).to(original_samples.dtype)
+        sigma_t = self.sigma_t.to(original_samples.device).to(original_samples.dtype)
+
+        timesteps = timesteps.to(original_samples.device)
+        alpha_t = alpha_t[timesteps].flatten()
+        while len(alpha_t.shape) < len(original_samples.shape):
+            alpha_t = alpha_t.unsqueeze(-1)
+
+        sigma_t = sigma_t[timesteps].flatten()
+        while len(sigma_t.shape) < len(original_samples.shape):
+            sigma_t = sigma_t.unsqueeze(-1)
+
+        velocity = alpha_t * noise - sigma_t * original_samples
+        return velocity
+
+    def __len__(self):
+        return self.config.num_train_timesteps

VibeVoice-tpu/src/vibevoice/schedule/timestep_sampler.py

@@ -0,0 +1,19 @@
+import math
+import torch
+
+
+class UniformSampler:
+    def __init__(self, timesteps = 1000):
+        self.timesteps = timesteps
+    def sample(self, batch_size, device):
+        return torch.randint(0, self.timesteps, (batch_size,), device=device)
+    
+class LogitNormalSampler:
+    def __init__(self, timesteps = 1000, m = 0, s = 1):
+        self.timesteps = timesteps
+        timesteps = torch.linspace(0, 1, timesteps)
+        logit = torch.log(timesteps / (1 - timesteps))
+        self.prob = torch.exp(-0.5 * (logit - m) ** 2 / s ** 2) / (s * math.sqrt(2 * math.pi))
+    def sample(self, batch_size, device):
+        return torch.multinomial(self.prob, batch_size, replacement=True).to(device)
+    

VibeVoice-tpu/src/vibevoice/scripts/convert_nnscaler_checkpoint_to_transformers.py

@@ -0,0 +1,166 @@
+#!/usr/bin/env python
+# coding=utf-8
+
+import argparse
+import json
+import os
+from pathlib import Path
+import re
+import torch
+from typing import Dict, List, Tuple
+
+from vibevoice.modular.configuration_vibevoice import (
+    VibeVoiceConfig
+)
+from vibevoice.modular.modeling_vibevoice import VibeVoiceForConditionalGeneration
+from transformers.utils import logging
+
+logger = logging.get_logger(__name__)
+
+def convert_vibevoice_nnscaler_checkpoint_to_hf(
+    checkpoint_path: str,
+    pytorch_dump_folder_path: str,
+    config_path: str = None,
+):
+    """
+    Convert a nnscaler VibeVoice checkpoint to HuggingFace format.
+    Supports both regular checkpoints and tensor parallel checkpoints.
+    """
+    
+    # Load regular checkpoint
+    logger.info(f"Loading regular checkpoint from {checkpoint_path}")
+    checkpoint = torch.load(checkpoint_path, map_location="cpu") # ['model', 'optimizer', 'lr_scheduler', 'train_status', 'train_args', 'rng_states', 'nnscaler', 'dataloader']
+    
+    # config = checkpoint['train_args']
+    init_config_name = checkpoint['train_args']['vars']['model_args']['config_path']['relative_path']
+    pretrained_name = checkpoint['train_args']['vars']['data_args']['tokenizer_path']
+    
+    init_config_path = Path(__file__).parent.parent / 'configs' / init_config_name.split('/')[-1]
+    if init_config_path.exists():
+        logger.info(f"Loading initial config from {init_config_path}")
+        with open(init_config_path, 'r') as f:
+            init_config = json.load(f)
+    else:
+        raise FileNotFoundError(f"Initial config file {init_config_path} not found. Please provide a valid path.")
+
+    tie_word_embeddings = init_config['decoder_config'].get('tie_word_embeddings', True)
+    logger.info(f"Tie word embeddings: {tie_word_embeddings}")
+
+    init_config['decoder_config']['use_cache'] = True
+    config = VibeVoiceConfig(**init_config, tie_word_embeddings=tie_word_embeddings)
+
+    # # Extract the model state dict
+    model_state_dict = {k.replace('model.model.', 'model.'): v for k, v in checkpoint["model"].items() if k.startswith('model.model.')}
+    if not tie_word_embeddings and 'model.lm_head.weight' in checkpoint["model"].keys():
+        # If not tying weights, we need to add the lm_head weight separately
+        model_state_dict['lm_head.weight'] = checkpoint["model"]['model.lm_head.weight']
+    
+    # Override with provided config if available
+    if config_path:
+        logger.info(f"Loading config from {config_path}")
+        with open(config_path, 'r') as f:
+            config_dict = json.load(f)
+        config = VibeVoiceConfig.from_dict(config_dict)
+    
+    # Set the default dtype to bfloat16 before creating the model
+    original_dtype = torch.get_default_dtype()
+    torch.set_default_dtype(torch.bfloat16)
+
+    # Create the HuggingFace model
+    logger.info("Creating HuggingFace VibeVoiceForConditionalGeneration model")
+    model = VibeVoiceForConditionalGeneration(config)
+    
+    # Restore original dtype
+    torch.set_default_dtype(original_dtype)
+
+    # Load the state dict
+    logger.info("Loading weights into model")
+    missing_keys, unexpected_keys = model.load_state_dict(model_state_dict, strict=False)
+    
+    if missing_keys:
+        logger.warning(f"Missing keys: {missing_keys}")
+    if unexpected_keys:
+        logger.warning(f"Unexpected keys: {unexpected_keys}")
+    
+    # Create output directory
+    os.makedirs(pytorch_dump_folder_path, exist_ok=True)
+    
+    # Save the model and config
+    logger.info(f"Saving model to {pytorch_dump_folder_path}")
+    
+    # Save config
+    config.save_pretrained(pytorch_dump_folder_path)
+    
+    # Save VibeVoiceProcessor configuration
+    logger.info("Saving VibeVoiceProcessor configuration")
+    processor_config = {
+        "processor_class": "VibeVoiceProcessor",
+        "speech_tok_compress_ratio": 3200,
+        "db_normalize": True,
+        # Audio processor configuration
+        "audio_processor": {
+            "feature_extractor_type": "VibeVoiceTokenizerProcessor",
+            "sampling_rate": 24000,
+            "normalize_audio": True,
+            "target_dB_FS": -25,
+            "eps": 1e-6,
+        },
+        "language_model_pretrained_name": pretrained_name,
+    }
+    
+    processor_config_path = os.path.join(pytorch_dump_folder_path, "preprocessor_config.json")
+    with open(processor_config_path, 'w') as f:
+        json.dump(processor_config, f, indent=2)
+    logger.info(f"Saved processor config to {processor_config_path}")
+    
+    # Save model with sharding
+    # save_pretrained handles tied weights automatically
+    logger.info("Saving model weights with sharding...")
+    model.save_pretrained(
+        pytorch_dump_folder_path,
+        max_shard_size="2GB",  # Set maximum size for each shard
+        safe_serialization=True  # Ensure saving in .safetensors format
+    )
+    logger.info(f"Model weights saved to {pytorch_dump_folder_path}")
+    
+    logger.info("Conversion complete!")
+    
+    # Verify the saved model can be loaded
+    logger.info("Verifying saved model...")
+    loaded_model = VibeVoiceForConditionalGeneration.from_pretrained(pytorch_dump_folder_path)
+    logger.info("Model successfully loaded from saved checkpoint!")
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--nnscaler_checkpoint_path",
+        type=str,
+        required=True,
+        help="Path to the fairseq checkpoint (.pt file). For tensor parallel checkpoints, "
+             "provide any one of the part files (e.g., checkpoint_1_5000-model_part-0.pt), "
+             "and the script will automatically detect and merge all parts.",
+    )
+    parser.add_argument(
+        "--pytorch_dump_folder_path", 
+        type=str,
+        required=True,
+        help="Path to the output PyTorch model directory",
+    )
+    parser.add_argument(
+        "--config_path",
+        type=str,
+        default=None,
+        help="Optional path to a config JSON file to override extracted config",
+    )
+    
+    args = parser.parse_args()
+    
+    convert_vibevoice_nnscaler_checkpoint_to_hf(
+        args.nnscaler_checkpoint_path,
+        args.pytorch_dump_folder_path,
+        args.config_path,
+    )
+
+
+if __name__ == "__main__":
+    main()

VibeVoice-tpu/src/vibevoice_surgery_colab.ipynb

@@ -0,0 +1,2156 @@
+{
+ "nbformat": 4,
+ "nbformat_minor": 0,
+ "metadata": {
+  "colab": {
+   "provenance": [],
+   "gpuType": "T4"
+  },
+  "kernelspec": {
+   "name": "python3",
+   "display_name": "Python 3"
+  },
+  "language_info": {
+   "name": "python"
+  },
+  "accelerator": "GPU",
+  "gpuClass": "standard"
+ },
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# 🔬 VibeVoice Surgery — Colab Notebook\n",
+    "## Replacing Qwen2.5-7B with Qwen3-4B + Surgery Module\n",
+    "\n",
+    "This notebook performs **model surgery** on `VibeVoice-7B`, replacing the Qwen2.5-7B\n",
+    "language model with Qwen3-4B and adding a **Surgery Module** to bridge the hidden\n",
+    "dimension gap (2560 → 3584) for the Diffusion Head.\n",
+    "\n",
+    "### Architecture Overview\n",
+    "\n",
+    "```\n",
+    "Audio → AcousticTokenizer (64-dim) → AcousticConnector → (2560-dim)\n",
+    "Audio → SemanticTokenizer (128-dim) → SemanticConnector → (2560-dim)\n",
+    "Combined → Qwen3-4B → hidden_states[37 × 2560-dim]\n",
+    "  → SurgeryModule → (3584-dim) → DiffusionHead → Speech\n",
+    "  → LMHead → Text Tokens\n",
+    "```\n",
+    "\n",
+    "### Surgery Module Pipeline\n",
+    "1. **Hierarchical Feature Extraction** — extract hidden states from 4 intermediate Qwen3 layers\n",
+    "2. **Learnable Weighted Sum** — softmax-weighted average\n",
+    "3. **RMSNorm** — numerical stabilisation\n",
+    "4. **SwiGLU** — non-linear translation between vector spaces\n",
+    "5. **Linear Projection** — upscale 2560 → 3584\n",
+    "\n",
+    "### Requirements\n",
+    "- GPU with ≥16 GB VRAM (T4, A100, etc.)\n",
+    "- ~30 GB system RAM for surgery phase\n",
+    "- `transformers >= 4.51.0` (for Qwen3 support)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "---\n",
+    "## 1. Install Dependencies"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Install/upgrade dependencies\n",
+    "!pip install -q \"transformers>=4.51.0\" accelerate torch torchvision\n",
+    "!pip install -q peft tqdm safetensors\n",
+    "\n",
+    "# Verify GPU availability\n",
+    "import torch\n",
+    "print(f\"CUDA available: {torch.cuda.is_available()}\")\n",
+    "print(f\"GPU count: {torch.cuda.device_count()}\")\n",
+    "for i in range(torch.cuda.device_count()):\n",
+    "    print(f\"  GPU {i}: {torch.cuda.get_device_name(i)} — {torch.cuda.get_device_properties(i).total_mem / 1e9:.1f} GB\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "---\n",
+    "## 2. Clone VibeVoice Repository"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "import sys\n",
+    "\n",
+    "# Clone the VibeVoice repository if not already present\n",
+    "REPO_URL = \"https://github.com/microsoft/VibeVoice.git\"  # Adjust URL as needed\n",
+    "REPO_DIR = \"/content/VibeVoice\"\n",
+    "\n",
+    "if not os.path.exists(REPO_DIR):\n",
+    "    !git clone $REPO_URL $REPO_DIR\n",
+    "else:\n",
+    "    print(f\"Repository already exists at {REPO_DIR}\")\n",
+    "\n",
+    "# Add src to path\n",
+    "SRC_DIR = os.path.join(REPO_DIR, \"src\")\n",
+    "if SRC_DIR not in sys.path:\n",
+    "    sys.path.insert(0, SRC_DIR)\n",
+    "\n",
+    "os.chdir(SRC_DIR)\n",
+    "print(f\"Working directory: {os.getcwd()}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "---\n",
+    "## 3. Global Configuration"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import torch\n",
+    "import torch.nn as nn\n",
+    "import torch.nn.functional as F\n",
+    "\n",
+    "# ── Precision ──\n",
+    "# T4 GPUs (Turing architecture) do NOT support bfloat16 efficiently.\n",
+    "# Use float16 for T4. For A100/H100, you can use bfloat16.\n",
+    "DTYPE = torch.float16\n",
+    "\n",
+    "# ── Qwen3-4B dimensions ──\n",
+    "QWEN3_HIDDEN_SIZE = 2560\n",
+    "QWEN3_NUM_LAYERS = 36\n",
+    "QWEN3_VOCAB_SIZE = 151936\n",
+    "QWEN3_MODEL_ID = \"Qwen/Qwen3-4B-Instruct-2507\"\n",
+    "\n",
+    "# ── VibeVoice Diffusion Head dimensions (unchanged) ──\n",
+    "DIFFUSION_HIDDEN_SIZE = 3584\n",
+    "\n",
+    "# ── Surgery: which intermediate layers of Qwen3 to extract (0-indexed) ──\n",
+    "# Layers 24, 28, 32, 34 out of 36 total\n",
+    "SURGERY_LAYER_INDICES = [24, 28, 32, 34]\n",
+    "\n",
+    "# ── Attention implementation ──\n",
+    "# T4 GPUs (Turing architecture) do NOT support flash_attention_2.\n",
+    "# Always use \"sdpa\" for T4 / Turing compatibility.\n",
+    "ATTN_IMPL = \"sdpa\"\n",
+    "\n",
+    "# ── Model paths ──\n",
+    "VIBEVOICE_MODEL_ID = \"vibevoice/VibeVoice-7B\"\n",
+    "OUTPUT_DIR = \"/content/vibevoice_qwen3_surgery\"\n",
+    "\n",
+    "print(f\"╔══════════════════════════════════════════════════════════════╗\")\n",
+    "print(f\"║  VibeVoice Surgery — Configuration                          ║\")\n",
+    "print(f\"╠══════════════════════════════════════════════════════════════╣\")\n",
+    "print(f\"║  Dtype:            {str(DTYPE):<42}║\")\n",
+    "print(f\"║  Attention:        {ATTN_IMPL:<42}║\")\n",
+    "print(f\"║  Qwen3 hidden:     {QWEN3_HIDDEN_SIZE:<42}║\")\n",
+    "print(f\"║  Qwen3 layers:     {QWEN3_NUM_LAYERS:<42}║\")\n",
+    "print(f\"║  Diffusion hidden: {DIFFUSION_HIDDEN_SIZE:<42}║\")\n",
+    "print(f\"║  Surgery layers:   {str(SURGERY_LAYER_INDICES):<42}║\")\n",
+    "print(f\"╚══════════════════════════════════════════════════════════════╝\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "---\n",
+    "## 4. Monkey-patch VibeVoiceConfig for Qwen3 Support\n",
+    "\n",
+    "The original `VibeVoiceConfig` only accepts `decoder_config` with `model_type=\"qwen2\"`.\n",
+    "This patch adds support for `model_type=\"qwen3\"`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import types\n",
+    "import functools\n",
+    "import warnings\n",
+    "from typing import Optional, Tuple, Union, List, Dict, Any\n",
+    "\n",
+    "from transformers import (\n",
+    "    AutoModel,\n",
+    "    AutoModelForCausalLM,\n",
+    "    AutoConfig,\n",
+    "    AutoTokenizer,\n",
+    ")\n",
+    "from transformers.modeling_outputs import BaseModelOutputWithPast, ModelOutput\n",
+    "from transformers.models.llama.modeling_llama import LlamaRMSNorm\n",
+    "from transformers.utils import logging\n",
+    "\n",
+    "# Import VibeVoice components\n",
+    "from vibevoice.modular.configuration_vibevoice import (\n",
+    "    VibeVoiceConfig,\n",
+    "    VibeVoiceDiffusionHeadConfig,\n",
+    ")\n",
+    "from vibevoice.modular.modeling_vibevoice import (\n",
+    "    VibeVoiceModel,\n",
+    "    VibeVoiceForConditionalGeneration,\n",
+    "    SpeechConnector,\n",
+    ")\n",
+    "from vibevoice.modular.modeling_vibevoice_inference import (\n",
+    "    VibeVoiceForConditionalGenerationInference,\n",
+    "    VibeVoiceCausalLMOutputWithPast,\n",
+    "    VibeVoiceGenerationOutput,\n",
+    "    VibeVoiceTokenConstraintProcessor,\n",
+    ")\n",
+    "from vibevoice.modular.modular_vibevoice_tokenizer import VibeVoiceTokenizerStreamingCache\n",
+    "\n",
+    "logger = logging.get_logger(__name__)\n",
+    "print(\"✅ VibeVoice modules imported successfully\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def _patch_vibevoice_config_for_qwen3():\n",
+    "    \"\"\"\n",
+    "    Monkey-patch VibeVoiceConfig.__init__ to accept Qwen3Config as decoder_config.\n",
+    "    \n",
+    "    The original VibeVoiceConfig only accepts decoder_config with model_type=\"qwen2\".\n",
+    "    This patch adds support for model_type=\"qwen3\" by importing Qwen3Config and\n",
+    "    handling it alongside Qwen2Config.\n",
+    "    \"\"\"\n",
+    "    try:\n",
+    "        from transformers import Qwen3Config\n",
+    "    except ImportError:\n",
+    "        raise ImportError(\n",
+    "            \"Qwen3Config not found. Please upgrade transformers: \"\n",
+    "            \"pip install 'transformers>=4.51.0'\"\n",
+    "        )\n",
+    "    \n",
+    "    from transformers.models.qwen2.configuration_qwen2 import Qwen2Config\n",
+    "    from transformers.configuration_utils import PretrainedConfig\n",
+    "    \n",
+    "    _orig_init = VibeVoiceConfig.__init__\n",
+    "    \n",
+    "    def _new_init(\n",
+    "        self,\n",
+    "        acoustic_tokenizer_config=None,\n",
+    "        semantic_tokenizer_config=None,\n",
+    "        decoder_config=None,\n",
+    "        diffusion_head_config=None,\n",
+    "        **kwargs\n",
+    "    ):\n",
+    "        kwargs[\"_attn_implementation_autoset\"] = False\n",
+    "        \n",
+    "        # ── acoustic_tokenizer_config ──\n",
+    "        if acoustic_tokenizer_config is None:\n",
+    "            self.acoustic_tokenizer_config = self.sub_configs[\"acoustic_tokenizer_config\"]()\n",
+    "        elif isinstance(acoustic_tokenizer_config, dict):\n",
+    "            acoustic_tokenizer_config[\"model_type\"] = \"vibevoice_acoustic_tokenizer\"\n",
+    "            self.acoustic_tokenizer_config = self.sub_configs[\"acoustic_tokenizer_config\"](\n",
+    "                **acoustic_tokenizer_config\n",
+    "            )\n",
+    "        else:\n",
+    "            self.acoustic_tokenizer_config = acoustic_tokenizer_config\n",
+    "        \n",
+    "        # ── semantic_tokenizer_config ──\n",
+    "        if semantic_tokenizer_config is None:\n",
+    "            self.semantic_tokenizer_config = self.sub_configs[\"semantic_tokenizer_config\"]()\n",
+    "        elif isinstance(semantic_tokenizer_config, dict):\n",
+    "            semantic_tokenizer_config[\"model_type\"] = \"vibevoice_semantic_tokenizer\"\n",
+    "            self.semantic_tokenizer_config = self.sub_configs[\"semantic_tokenizer_config\"](\n",
+    "                **semantic_tokenizer_config\n",
+    "            )\n",
+    "        else:\n",
+    "            self.semantic_tokenizer_config = semantic_tokenizer_config\n",
+    "        \n",
+    "        # ── decoder_config (NOW SUPPORTS QWEN3!) ──\n",
+    "        if decoder_config is None:\n",
+    "            self.decoder_config = self.sub_configs[\"decoder_config\"]()\n",
+    "        elif isinstance(decoder_config, dict):\n",
+    "            model_type = decoder_config.get(\"model_type\", \"\")\n",
+    "            if model_type == \"qwen2\":\n",
+    "                self.decoder_config = Qwen2Config(**decoder_config)\n",
+    "            elif model_type == \"qwen3\":\n",
+    "                self.decoder_config = Qwen3Config(**decoder_config)\n",
+    "            else:\n",
+    "                try:\n",
+    "                    self.decoder_config = Qwen2Config(**decoder_config)\n",
+    "                except Exception:\n",
+    "                    raise ValueError(\n",
+    "                        f\"Unsupported decoder model type: {model_type}. \"\n",
+    "                        f\"Supported: 'qwen2', 'qwen3'\"\n",
+    "                    )\n",
+    "        elif isinstance(decoder_config, (Qwen2Config, Qwen3Config)):\n",
+    "            self.decoder_config = decoder_config\n",
+    "        elif isinstance(decoder_config, PretrainedConfig):\n",
+    "            self.decoder_config = decoder_config\n",
+    "        else:\n",
+    "            raise ValueError(f\"Invalid decoder_config type: {type(decoder_config)}\")\n",
+    "        \n",
+    "        # ── diffusion_head_config ──\n",
+    "        if diffusion_head_config is None:\n",
+    "            self.diffusion_head_config = self.sub_configs[\"diffusion_head_config\"]()\n",
+    "        elif isinstance(diffusion_head_config, dict):\n",
+    "            diffusion_head_config[\"model_type\"] = \"vibevoice_diffusion_head\"\n",
+    "            self.diffusion_head_config = self.sub_configs[\"diffusion_head_config\"](\n",
+    "                **diffusion_head_config\n",
+    "            )\n",
+    "        else:\n",
+    "            self.diffusion_head_config = diffusion_head_config\n",
+    "        \n",
+    "        # Derived dimensions\n",
+    "        self.acoustic_vae_dim = getattr(self.acoustic_tokenizer_config, \"vae_dim\", 64)\n",
+    "        self.semantic_vae_dim = getattr(self.semantic_tokenizer_config, \"vae_dim\", 128)\n",
+    "        \n",
+    "        PretrainedConfig.__init__(self, **kwargs)\n",
+    "    \n",
+    "    VibeVoiceConfig.__init__ = _new_init\n",
+    "    print(\"✅ VibeVoiceConfig patched to accept Qwen3Config\")\n",
+    "\n",
+    "\n",
+    "# Apply the patch immediately\n",
+    "_patch_vibevoice_config_for_qwen3()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "---\n",
+    "## 5. Surgery Module Definition\n",
+    "\n",
+    "The `Qwen3SurgeryModule` bridges Qwen3-4B (2560-dim) to the VibeVoice Diffusion Head (3584-dim).\n",
+    "\n",
+    "### Pipeline:\n",
+    "1. **Hierarchical Feature Extraction** — extract hidden states from 4 intermediate Qwen3 layers (rich prosody / emotion / phonetic info)\n",
+    "2. **Learnable Weighted Sum** — softmax-weighted average (memory-efficient)\n",
+    "3. **RMSNorm** — numerical stabilisation across layer magnitudes\n",
+    "4. **SwiGLU** — non-linear translation between vector spaces\n",
+    "5. **Linear Projection** — upscale 2560 → 3584 for the Diffusion Head\n",
+    "\n",
+    "### Initialization Strategy:\n",
+    "- **Zero-init output projection** → safe start for fine-tuning (model behaves like original at start)\n",
+    "- **Zero-init layer weights** → uniform weighting after softmax\n",
+    "- **Normal init SwiGLU** → standard initialization for non-linear layers"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class Qwen3SurgeryModule(nn.Module):\n",
+    "    \"\"\"\n",
+    "    Bridges Qwen3-4B (2560-dim) to VibeVoice Diffusion Head (3584-dim).\n",
+    "\n",
+    "    Pipeline:\n",
+    "      1. Hierarchical Feature Extraction — extract hidden states from 4\n",
+    "         intermediate Qwen3 layers (rich prosody / emotion / phonetic info)\n",
+    "      2. Learnable Weighted Sum — softmax-weighted average (memory-efficient)\n",
+    "      3. RMSNorm — numerical stabilisation across layer magnitudes\n",
+    "      4. SwiGLU — non-linear translation between vector spaces\n",
+    "      5. Linear Projection — upscale 2560 → 3584 for the Diffusion Head\n",
+    "\n",
+    "    Args:\n",
+    "        input_dim:       Qwen3 hidden size (2560)\n",
+    "        output_dim:      Diffusion Head hidden size (3584)\n",
+    "        layer_indices:   0-indexed transformer layer indices to extract\n",
+    "        rms_norm_eps:    Epsilon for RMSNorm\n",
+    "    \"\"\"\n",
+    "\n",
+    "    def __init__(\n",
+    "        self,\n",
+    "        input_dim: int = 2560,\n",
+    "        output_dim: int = 3584,\n",
+    "        layer_indices: Optional[List[int]] = None,\n",
+    "        rms_norm_eps: float = 1e-6,\n",
+    "    ):\n",
+    "        super().__init__()\n",
+    "        if layer_indices is None:\n",
+    "            layer_indices = [24, 28, 32, 34]\n",
+    "\n",
+    "        self.input_dim = input_dim\n",
+    "        self.output_dim = output_dim\n",
+    "        self.layer_indices = layer_indices\n",
+    "        self.num_layers = len(layer_indices)\n",
+    "\n",
+    "        # Step 2: Learnable Weighted Sum\n",
+    "        self.layer_weights = nn.Parameter(torch.zeros(self.num_layers))\n",
+    "\n",
+    "        # Step 3: RMSNorm\n",
+    "        self.norm = LlamaRMSNorm(input_dim, eps=rms_norm_eps)\n",
+    "\n",
+    "        # Step 4: SwiGLU\n",
+    "        self.swiglu_gate = nn.Linear(input_dim, input_dim, bias=False)\n",
+    "        self.swiglu_up = nn.Linear(input_dim, input_dim, bias=False)\n",
+    "\n",
+    "        # Step 5: Linear Projection\n",
+    "        self.output_proj = nn.Linear(input_dim, output_dim, bias=False)\n",
+    "\n",
+    "        self._initialize_weights()\n",
+    "\n",
+    "    def _initialize_weights(self):\n",
+    "        nn.init.normal_(self.swiglu_gate.weight, std=0.02)\n",
+    "        nn.init.normal_(self.swiglu_up.weight, std=0.02)\n",
+    "        # Zero-init output → safe start for fine-tuning\n",
+    "        nn.init.zeros_(self.output_proj.weight)\n",
+    "        nn.init.zeros_(self.layer_weights)\n",
+    "\n",
+    "    def forward(self, all_hidden_states: Tuple[torch.Tensor, ...]) -> torch.Tensor:\n",
+    "        \"\"\"\n",
+    "        Args:\n",
+    "            all_hidden_states: Tuple of (num_layers+1) tensors [B, Seq, input_dim].\n",
+    "                Index 0 = embedding, index i+1 = transformer layer i.\n",
+    "\n",
+    "        Returns:\n",
+    "            Transformed features [B, Seq, output_dim]\n",
+    "        \"\"\"\n",
+    "        # Step 1: Extract selected layers\n",
+    "        selected = [all_hidden_states[i + 1] for i in self.layer_indices]\n",
+    "\n",
+    "        # Step 2: Weighted sum\n",
+    "        weights = F.softmax(self.layer_weights, dim=0)\n",
+    "        merged = torch.zeros_like(selected[0])\n",
+    "        for w, h in zip(weights, selected):\n",
+    "            merged = merged + w * h\n",
+    "\n",
+    "        # Step 3: Normalise\n",
+    "        merged = self.norm(merged)\n",
+    "\n",
+    "        # Step 4: SwiGLU\n",
+    "        gate = F.silu(self.swiglu_gate(merged))\n",
+    "        up = self.swiglu_up(merged)\n",
+    "        hidden = gate * up\n",
+    "\n",
+    "        # Step 5: Project\n",
+    "        return self.output_proj(hidden)\n",
+    "\n",
+    "    def extra_repr(self) -> str:\n",
+    "        return (\n",
+    "            f\"input_dim={self.input_dim}, output_dim={self.output_dim}, \"\n",
+    "            f\"layers={self.layer_indices}\"\n",
+    "        )\n",
+    "\n",
+    "\n",
+    "print(\"✅ Surgery Module class defined\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "---\n",
+    "## 6. Surgery Functions\n",
+    "\n",
+    "Core functions that perform the actual model surgery:\n",
+    "- `create_qwen3_config_for_surgery()` — creates Qwen3Config with correct parameters\n",
+    "- `perform_surgery()` — the main surgery function that replaces LM, connectors, and adds surgery module\n",
+    "- `_patch_base_model_forward()` — forces `output_hidden_states=True`\n",
+    "- `_patch_inference_forward()` — includes hidden_states in forward output\n",
+    "- `_patch_generate_method()` — integrates surgery module into generation loop"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def create_qwen3_config_for_surgery():\n",
+    "    \"\"\"Create a Qwen3Config with the correct parameters for surgery.\"\"\"\n",
+    "    from transformers import Qwen3Config\n",
+    "    \n",
+    "    return Qwen3Config(\n",
+    "        hidden_size=QWEN3_HIDDEN_SIZE,\n",
+    "        num_hidden_layers=QWEN3_NUM_LAYERS,\n",
+    "        num_attention_heads=32,\n",
+    "        num_key_value_heads=8,\n",
+    "        intermediate_size=9728,\n",
+    "        hidden_act=\"silu\",\n",
+    "        max_position_embeddings=262144,\n",
+    "        max_window_layers=36,\n",
+    "        rms_norm_eps=1e-6,\n",
+    "        vocab_size=QWEN3_VOCAB_SIZE,\n",
+    "        tie_word_embeddings=True,\n",
+    "        rope_theta=5000000,\n",
+    "        head_dim=128,\n",
+    "        torch_dtype=\"float16\",\n",
+    "        _attn_implementation=ATTN_IMPL,\n",
+    "    )\n",
+    "\n",
+    "\n",
+    "print(\"✅ Qwen3 config factory defined\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def _update_config_for_qwen3(model):\n",
+    "    \"\"\"Update the model's config to reflect Qwen3 decoder dimensions.\"\"\"\n",
+    "    qwen3_config = create_qwen3_config_for_surgery()\n",
+    "    model.config.decoder_config = qwen3_config\n",
+    "    model.config.tie_word_embeddings = True\n",
+    "\n",
+    "\n",
+    "def _patch_base_model_forward(model: VibeVoiceModel):\n",
+    "    \"\"\"\n",
+    "    Patch VibeVoiceModel.forward to always return hidden_states.\n",
+    "    The Surgery Module needs access to intermediate layer hidden states.\n",
+    "    \"\"\"\n",
+    "    original_forward = model.forward\n",
+    "\n",
+    "    @functools.wraps(original_forward)\n",
+    "    def patched_forward(\n",
+    "        self,\n",
+    "        input_ids=None,\n",
+    "        attention_mask=None,\n",
+    "        position_ids=None,\n",
+    "        past_key_values=None,\n",
+    "        inputs_embeds=None,\n",
+    "        use_cache=None,\n",
+    "        output_attentions=None,\n",
+    "        output_hidden_states=None,  # Will be forced True\n",
+    "        return_dict=None,\n",
+    "        cache_position=None,\n",
+    "        **kwargs,\n",
+    "    ):\n",
+    "        return original_forward(\n",
+    "            input_ids=input_ids,\n",
+    "            attention_mask=attention_mask,\n",
+    "            position_ids=position_ids,\n",
+    "            past_key_values=past_key_values,\n",
+    "            inputs_embeds=inputs_embeds,\n",
+    "            use_cache=use_cache,\n",
+    "            output_attentions=output_attentions,\n",
+    "            output_hidden_states=True,  # Always True for Surgery Module\n",
+    "            return_dict=return_dict,\n",
+    "            cache_position=cache_position,\n",
+    "            **kwargs,\n",
+    "        )\n",
+    "\n",
+    "    model.forward = types.MethodType(patched_forward, model)\n",
+    "    print(\"   ✓ Base model forward patched (output_hidden_states=True)\")\n",
+    "\n",
+    "\n",
+    "print(\"✅ Config and base forward patch functions defined\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def _patch_inference_forward(model: VibeVoiceForConditionalGenerationInference):\n",
+    "    \"\"\"\n",
+    "    Patch the inference forward to:\n",
+    "      1. Force output_hidden_states=True\n",
+    "      2. Include hidden_states in the return value (needed by surgery module)\n",
+    "    \"\"\"\n",
+    "    original_forward = model.__class__.forward\n",
+    "\n",
+    "    def patched_forward(\n",
+    "        self,\n",
+    "        input_ids=None,\n",
+    "        attention_mask=None,\n",
+    "        position_ids=None,\n",
+    "        past_key_values=None,\n",
+    "        inputs_embeds=None,\n",
+    "        labels=None,\n",
+    "        use_cache=None,\n",
+    "        output_attentions=None,\n",
+    "        output_hidden_states=None,\n",
+    "        return_dict=None,\n",
+    "        cache_position=None,\n",
+    "        speech_tensors=None,\n",
+    "        speech_masks=None,\n",
+    "        speech_input_mask=None,\n",
+    "        logits_to_keep=0,\n",
+    "        **kwargs,\n",
+    "    ):\n",
+    "        return_dict = return_dict if return_dict is not None else self.config.use_return_dict\n",
+    "\n",
+    "        # Get embeddings\n",
+    "        if inputs_embeds is None:\n",
+    "            inputs_embeds = self.model.get_input_embeddings()(input_ids)\n",
+    "\n",
+    "        # Process speech inputs\n",
+    "        if speech_tensors is not None and speech_masks is not None:\n",
+    "            acoustic_features, speech_embeds = self._process_speech_inputs(\n",
+    "                speech_tensors.to(self.dtype), speech_masks\n",
+    "            )\n",
+    "            if speech_input_mask is not None:\n",
+    "                inputs_embeds[speech_input_mask] = speech_embeds\n",
+    "\n",
+    "        # Always output hidden states for Surgery Module\n",
+    "        outputs = self.model(\n",
+    "            inputs_embeds=inputs_embeds,\n",
+    "            attention_mask=attention_mask,\n",
+    "            position_ids=position_ids,\n",
+    "            past_key_values=past_key_values,\n",
+    "            use_cache=use_cache,\n",
+    "            output_attentions=output_attentions,\n",
+    "            output_hidden_states=True,  # Always True!\n",
+    "            return_dict=return_dict,\n",
+    "            cache_position=cache_position,\n",
+    "            **kwargs,\n",
+    "        )\n",
+    "\n",
+    "        hidden_states = outputs[0] if not return_dict else outputs.last_hidden_state\n",
+    "        slice_indices = (\n",
+    "            slice(-logits_to_keep, None)\n",
+    "            if isinstance(logits_to_keep, int)\n",
+    "            else logits_to_keep\n",
+    "        )\n",
+    "        logits = self.lm_head(hidden_states[:, slice_indices, :])\n",
+    "\n",
+    "        if labels is not None:\n",
+    "            raise NotImplementedError(\"Loss computation not implemented in surgery version.\")\n",
+    "\n",
+    "        # KEY CHANGE: Include hidden_states in the output\n",
+    "        return VibeVoiceCausalLMOutputWithPast(\n",
+    "            logits=logits,\n",
+    "            past_key_values=outputs.past_key_values,\n",
+    "            last_hidden_state=hidden_states,\n",
+    "            hidden_states=outputs.hidden_states,  # ← All layer hidden states\n",
+    "            attentions=outputs.attentions,\n",
+    "        )\n",
+    "\n",
+    "    model.forward = types.MethodType(patched_forward, model)\n",
+    "    print(\"   ✓ Inference forward patched (includes hidden_states)\")\n",
+    "\n",
+    "\n",
+    "print(\"✅ Inference forward patch function defined\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import copy\n",
+    "from tqdm import tqdm\n",
+    "from transformers.generation import GenerationConfig, LogitsProcessorList, StoppingCriteriaList\n",
+    "\n",
+    "\n",
+    "def _patch_generate_method(model: VibeVoiceForConditionalGenerationInference):\n",
+    "    \"\"\"\n",
+    "    Patch generate to use the Surgery Module for conditioning.\n",
+    "    \n",
+    "    Key changes vs. original generate:\n",
+    "      1. Forward calls use output_hidden_states=True\n",
+    "      2. Conditioning uses Surgery Module instead of last_hidden_state\n",
+    "      3. Device-aware surgery module calls for multi-GPU\n",
+    "    \"\"\"\n",
+    "\n",
+    "    def patched_generate(\n",
+    "        self,\n",
+    "        inputs=None,\n",
+    "        generation_config=None,\n",
+    "        logits_processor=None,\n",
+    "        stopping_criteria=None,\n",
+    "        prefix_allowed_tokens_fn=None,\n",
+    "        synced_gpus=None,\n",
+    "        assistant_model=None,\n",
+    "        audio_streamer=None,\n",
+    "        negative_prompt_ids=None,\n",
+    "        negative_prompt_attention_mask=None,\n",
+    "        speech_tensors=None,\n",
+    "        speech_masks=None,\n",
+    "        speech_input_mask=None,\n",
+    "        return_speech=True,\n",
+    "        cfg_scale=1.0,\n",
+    "        stop_check_fn=None,\n",
+    "        **kwargs,\n",
+    "    ):\n",
+    "        \"\"\"Modified generate that uses Surgery Module for conditioning.\"\"\"\n",
+    "        # ── Setup ──\n",
+    "        tokenizer = kwargs.pop(\"tokenizer\", None)\n",
+    "        parsed_scripts = kwargs.pop(\"parsed_scripts\", None)\n",
+    "        all_speakers_list = kwargs.pop(\"all_speakers_list\", None)\n",
+    "        max_length_times = kwargs.pop(\"max_length_times\", 2)\n",
+    "\n",
+    "        if kwargs.get(\"max_new_tokens\", None) is None:\n",
+    "            kwargs[\"max_new_tokens\"] = (\n",
+    "                self.config.decoder_config.max_position_embeddings\n",
+    "                - kwargs[\"input_ids\"].shape[-1]\n",
+    "            )\n",
+    "\n",
+    "        (\n",
+    "            generation_config, model_kwargs, input_ids,\n",
+    "            logits_processor, stopping_criteria,\n",
+    "        ) = self._build_generate_config_model_kwargs(\n",
+    "            generation_config, inputs, tokenizer,\n",
+    "            return_processors=True, **kwargs,\n",
+    "        )\n",
+    "\n",
+    "        negative_kwargs = {\n",
+    "            \"input_ids\": torch.full(\n",
+    "                (kwargs[\"input_ids\"].shape[0], 1),\n",
+    "                tokenizer.speech_start_id,\n",
+    "                dtype=torch.long, device=kwargs[\"input_ids\"].device,\n",
+    "            ),\n",
+    "            \"attention_mask\": torch.ones(\n",
+    "                (kwargs[\"input_ids\"].shape[0], 1),\n",
+    "                dtype=torch.long, device=kwargs[\"input_ids\"].device,\n",
+    "            ),\n",
+    "            \"max_new_tokens\": kwargs.get(\"max_new_tokens\", 100),\n",
+    "        }\n",
+    "        negative_generation_config, negative_model_kwargs, negative_input_ids = (\n",
+    "            self._build_generate_config_model_kwargs(\n",
+    "                None, None, tokenizer,\n",
+    "                return_processors=False, **negative_kwargs,\n",
+    "            )\n",
+    "        )\n",
+    "\n",
+    "        acoustic_cache = VibeVoiceTokenizerStreamingCache()\n",
+    "        semantic_cache = VibeVoiceTokenizerStreamingCache()\n",
+    "\n",
+    "        batch_size = input_ids.shape[0]\n",
+    "        device = input_ids.device\n",
+    "        finished_tags = torch.zeros(batch_size, dtype=torch.bool, device=device)\n",
+    "        correct_cnt = torch.zeros(batch_size, dtype=torch.long, device=device)\n",
+    "        is_prefill = True\n",
+    "        inputs_embeds = None\n",
+    "        verbose = kwargs.get(\"verbose\", False)\n",
+    "\n",
+    "        audio_chunks = [[] for _ in range(batch_size)]\n",
+    "\n",
+    "        initial_length = input_ids.shape[-1]\n",
+    "        initial_length_per_sample = model_kwargs[\"attention_mask\"].sum(dim=-1)\n",
+    "\n",
+    "        valid_tokens = [\n",
+    "            generation_config.speech_start_id,\n",
+    "            generation_config.speech_end_id,\n",
+    "            generation_config.speech_diffusion_id,\n",
+    "            generation_config.eos_token_id,\n",
+    "        ]\n",
+    "        if hasattr(generation_config, \"bos_token_id\") and generation_config.bos_token_id is not None:\n",
+    "            valid_tokens.append(generation_config.bos_token_id)\n",
+    "\n",
+    "        token_constraint_processor = VibeVoiceTokenConstraintProcessor(valid_tokens, device=device)\n",
+    "        if logits_processor is None:\n",
+    "            logits_processor = LogitsProcessorList()\n",
+    "        logits_processor.append(token_constraint_processor)\n",
+    "\n",
+    "        max_steps = min(\n",
+    "            generation_config.max_length - initial_length,\n",
+    "            int(max_length_times * initial_length),\n",
+    "        )\n",
+    "        max_step_per_sample = torch.minimum(\n",
+    "            generation_config.max_length - initial_length_per_sample,\n",
+    "            (max_length_times * initial_length_per_sample).long(),\n",
+    "        )\n",
+    "        reach_max_step_sample = torch.zeros(batch_size, dtype=torch.bool, device=device)\n",
+    "\n",
+    "        progress_bar = (\n",
+    "            tqdm(range(max_steps), desc=\"Generating\", leave=False)\n",
+    "            if kwargs.get(\"show_progress_bar\", True)\n",
+    "            else range(max_steps)\n",
+    "        )\n",
+    "\n",
+    "        # Device resolution for multi-GPU compatibility\n",
+    "        acoustic_device = next(self.model.acoustic_tokenizer.parameters()).device\n",
+    "        semantic_device = next(self.model.semantic_tokenizer.parameters()).device\n",
+    "        acoustic_connect_device = next(self.model.acoustic_connector.parameters()).device\n",
+    "        semantic_connect_device = next(self.model.semantic_connector.parameters()).device\n",
+    "\n",
+    "        # Helper: run surgery module with correct device placement\n",
+    "        def _run_surgery(hidden_states_tuple):\n",
+    "            \"\"\"Run surgery module on last token only, handling multi-GPU placement.\"\"\"\n",
+    "            surgery_mod = self.model.surgery_module\n",
+    "            surgery_device = next(surgery_mod.parameters()).device\n",
+    "            # Slice to last token only — avoids O(N²) on full sequence\n",
+    "            selected = tuple(h[:, -1:, :] for h in hidden_states_tuple)\n",
+    "            if selected[0].device != surgery_device:\n",
+    "                selected = tuple(h.to(surgery_device) for h in selected)\n",
+    "            return surgery_mod(selected)\n",
+    "\n",
+    "        # ── Generation Loop ──\n",
+    "        for step in progress_bar:\n",
+    "            if stop_check_fn is not None and stop_check_fn():\n",
+    "                if verbose:\n",
+    "                    print(f\"Generation stopped externally at step {step + 1}\")\n",
+    "                if audio_streamer is not None:\n",
+    "                    audio_streamer.end()\n",
+    "                break\n",
+    "\n",
+    "            if audio_streamer is not None and hasattr(audio_streamer, \"finished_flags\"):\n",
+    "                if any(audio_streamer.finished_flags):\n",
+    "                    if verbose:\n",
+    "                        print(f\"Audio generation stopped externally at step {step + 1}\")\n",
+    "                    break\n",
+    "\n",
+    "            if finished_tags.all():\n",
+    "                if hasattr(progress_bar, \"set_description\"):\n",
+    "                    progress_bar.set_description(\"Generation complete\")\n",
+    "                break\n",
+    "\n",
+    "            if input_ids.shape[-1] >= generation_config.max_length:\n",
+    "                print(f\"Reached max generation length {generation_config.max_length}\")\n",
+    "                reached = torch.arange(batch_size, device=device)[~finished_tags]\n",
+    "                if reached.numel() > 0:\n",
+    "                    reach_max_step_sample[reached] = True\n",
+    "                break\n",
+    "\n",
+    "            if hasattr(progress_bar, \"set_description\"):\n",
+    "                active = (~finished_tags).sum().item()\n",
+    "                progress_bar.set_description(f\"Generating (active: {active}/{batch_size})\")\n",
+    "\n",
+    "            model_inputs = self.prepare_inputs_for_generation(input_ids, **model_kwargs)\n",
+    "            if is_prefill:\n",
+    "                prefill_inputs = {\n",
+    "                    \"speech_tensors\": speech_tensors.to(device=device),\n",
+    "                    \"speech_masks\": speech_masks.to(device),\n",
+    "                    \"speech_input_mask\": speech_input_mask.to(device),\n",
+    "                }\n",
+    "                is_prefill = False\n",
+    "            else:\n",
+    "                _ = model_inputs.pop(\"inputs_embeds\", None)\n",
+    "                prefill_inputs = {\"inputs_embeds\": inputs_embeds}\n",
+    "\n",
+    "            # Forward\n",
+    "            outputs = self(\n",
+    "                **model_inputs, **prefill_inputs,\n",
+    "                logits_to_keep=1, return_dict=True,\n",
+    "                output_attentions=False, output_hidden_states=True,\n",
+    "            )\n",
+    "            model_kwargs = self._update_model_kwargs_for_generation(\n",
+    "                outputs, model_kwargs, is_encoder_decoder=False,\n",
+    "            )\n",
+    "\n",
+    "            next_token_logits = outputs.logits[:, -1, :].to(\n",
+    "                copy=True, dtype=torch.float32, device=input_ids.device,\n",
+    "            )\n",
+    "            next_token_scores = logits_processor(input_ids, next_token_logits)\n",
+    "\n",
+    "            if generation_config.do_sample:\n",
+    "                probs = nn.functional.softmax(next_token_scores, dim=-1)\n",
+    "                next_tokens = torch.multinomial(probs, num_samples=1).squeeze(1)\n",
+    "            else:\n",
+    "                next_tokens = torch.argmax(next_token_scores, dim=-1)\n",
+    "\n",
+    "            next_tokens[finished_tags] = generation_config.eos_token_id\n",
+    "            input_ids = torch.cat([input_ids, next_tokens[:, None]], dim=-1)\n",
+    "\n",
+    "            # Negative prompt update (non-refresh mode)\n",
+    "            if not kwargs.get(\"refresh_negative\", True):\n",
+    "                negative_model_inputs = self.prepare_inputs_for_generation(\n",
+    "                    negative_input_ids, **negative_model_kwargs\n",
+    "                )\n",
+    "                if negative_model_inputs[\"inputs_embeds\"] is None and inputs_embeds is not None:\n",
+    "                    negative_model_inputs[\"inputs_embeds\"] = inputs_embeds\n",
+    "                    negative_model_inputs[\"input_ids\"] = None\n",
+    "\n",
+    "                negative_outputs = self(\n",
+    "                    **negative_model_inputs,\n",
+    "                    logits_to_keep=0, return_dict=True,\n",
+    "                    output_attentions=False, output_hidden_states=True,\n",
+    "                )\n",
+    "                negative_model_kwargs = self._update_model_kwargs_for_generation(\n",
+    "                    negative_outputs, negative_model_kwargs, is_encoder_decoder=False,\n",
+    "                )\n",
+    "                negative_input_ids = torch.cat(\n",
+    "                    [negative_input_ids, next_tokens[:, None]], dim=-1\n",
+    "                )\n",
+    "\n",
+    "            # EOS handling\n",
+    "            if (next_tokens == generation_config.eos_token_id).any():\n",
+    "                eos_indices = (\n",
+    "                    (next_tokens == generation_config.eos_token_id)\n",
+    "                    .nonzero(as_tuple=False).squeeze(1)\n",
+    "                )\n",
+    "                new_eos = eos_indices[~finished_tags[eos_indices]]\n",
+    "                if new_eos.numel() > 0:\n",
+    "                    finished_tags[new_eos] = True\n",
+    "                    if verbose:\n",
+    "                        print(f\"Samples {new_eos.tolist()} reached EOS at step {step+1}.\", flush=True)\n",
+    "                    if audio_streamer is not None:\n",
+    "                        audio_streamer.end(new_eos)\n",
+    "\n",
+    "            # Max length handling\n",
+    "            max_reached = step >= max_step_per_sample\n",
+    "            new_max = torch.nonzero(max_reached & ~finished_tags, as_tuple=False).squeeze(1)\n",
+    "            if new_max.numel() > 0:\n",
+    "                finished_tags[new_max] = True\n",
+    "                reach_max_step_sample[new_max] = True\n",
+    "                if verbose:\n",
+    "                    print(f\"Samples {new_max.tolist()} reached max length at step {step+1}.\", flush=True)\n",
+    "                if audio_streamer is not None:\n",
+    "                    audio_streamer.end(new_max)\n",
+    "\n",
+    "            # speech_end\n",
+    "            diffusion_end = (\n",
+    "                (next_tokens == generation_config.speech_end_id)\n",
+    "                .nonzero(as_tuple=False).squeeze(1)\n",
+    "            )\n",
+    "            if diffusion_end.numel() > 0:\n",
+    "                acoustic_cache.set_to_zero(diffusion_end)\n",
+    "                semantic_cache.set_to_zero(diffusion_end)\n",
+    "\n",
+    "            # speech_begin — update negative prompt cache\n",
+    "            diffusion_start = torch.arange(batch_size, device=device)[\n",
+    "                ~finished_tags & (next_tokens == generation_config.speech_start_id)\n",
+    "            ]\n",
+    "            if diffusion_start.numel() > 0 and kwargs.get(\"refresh_negative\", True):\n",
+    "                for idx in diffusion_start.tolist():\n",
+    "                    negative_model_kwargs[\"attention_mask\"][idx, :] = 0\n",
+    "                    negative_model_kwargs[\"attention_mask\"][idx, -1] = 1\n",
+    "                for k_cache, v_cache in zip(\n",
+    "                    negative_model_kwargs[\"past_key_values\"].key_cache,\n",
+    "                    negative_model_kwargs[\"past_key_values\"].value_cache,\n",
+    "                ):\n",
+    "                    for idx in diffusion_start.tolist():\n",
+    "                        k_cache[idx, :, -1, :] = k_cache[idx, :, 0, :].clone()\n",
+    "                        v_cache[idx, :, -1, :] = v_cache[idx, :, 0, :].clone()\n",
+    "                for idx in diffusion_start.tolist():\n",
+    "                    negative_input_ids[idx, -1] = generation_config.speech_start_id\n",
+    "\n",
+    "            # Prepare next embeddings\n",
+    "            next_inputs_embeds = self.model.get_input_embeddings()(next_tokens).unsqueeze(1)\n",
+    "\n",
+    "            # ── Diffusion forward ──\n",
+    "            diffusion_indices = torch.arange(batch_size, device=device)[\n",
+    "                ~finished_tags & (next_tokens == generation_config.speech_diffusion_id)\n",
+    "            ]\n",
+    "\n",
+    "            if diffusion_indices.numel() > 0:\n",
+    "                # Negative pass for diffusion\n",
+    "                if kwargs.get(\"refresh_negative\", True):\n",
+    "                    negative_model_inputs = self.prepare_inputs_for_generation(\n",
+    "                        negative_input_ids, **negative_model_kwargs\n",
+    "                    )\n",
+    "                    if negative_model_inputs[\"inputs_embeds\"] is None and inputs_embeds is not None:\n",
+    "                        negative_model_inputs[\"inputs_embeds\"] = inputs_embeds\n",
+    "                        negative_model_inputs[\"input_ids\"] = None\n",
+    "\n",
+    "                    negative_outputs = self(\n",
+    "                        **negative_model_inputs,\n",
+    "                        logits_to_keep=0, return_dict=True,\n",
+    "                        output_attentions=False, output_hidden_states=True,\n",
+    "                    )\n",
+    "                    negative_model_kwargs = self._update_model_kwargs_for_generation(\n",
+    "                        negative_outputs, negative_model_kwargs, is_encoder_decoder=False,\n",
+    "                    )\n",
+    "                    negative_input_ids = torch.cat(\n",
+    "                        [negative_input_ids, next_tokens[:, None]], dim=-1\n",
+    "                    )\n",
+    "\n",
+    "                # Correct non-diffusion samples' KV cache\n",
+    "                non_diff_mask = ~finished_tags & (next_tokens != generation_config.speech_diffusion_id)\n",
+    "                if non_diff_mask.any():\n",
+    "                    non_diff_idx = torch.arange(batch_size, device=device)[non_diff_mask]\n",
+    "                    starts = correct_cnt[non_diff_idx]\n",
+    "\n",
+    "                    seq_len = negative_model_kwargs[\"attention_mask\"].shape[1]\n",
+    "                    for i, (s_idx, s_start) in enumerate(\n",
+    "                        zip(non_diff_idx.tolist(), starts.tolist())\n",
+    "                    ):\n",
+    "                        if s_start + 1 < seq_len - 1:\n",
+    "                            negative_model_kwargs[\"attention_mask\"][s_idx, s_start+1:] = \\\n",
+    "                                negative_model_kwargs[\"attention_mask\"][s_idx, s_start:-1].clone()\n",
+    "                        negative_model_kwargs[\"attention_mask\"][s_idx, s_start] = 0\n",
+    "\n",
+    "                    for k_cache, v_cache in zip(\n",
+    "                        negative_model_kwargs[\"past_key_values\"].key_cache,\n",
+    "                        negative_model_kwargs[\"past_key_values\"].value_cache,\n",
+    "                    ):\n",
+    "                        for s_idx, s_start in zip(non_diff_idx.tolist(), starts.tolist()):\n",
+    "                            if s_start + 1 < k_cache.shape[2] - 1:\n",
+    "                                k_cache[s_idx, :, s_start+1:, :] = \\\n",
+    "                                    k_cache[s_idx, :, s_start:-1, :].clone()\n",
+    "                                v_cache[s_idx, :, s_start+1:, :] = \\\n",
+    "                                    v_cache[s_idx, :, s_start:-1, :].clone()\n",
+    "\n",
+    "                    for s_idx, s_start in zip(non_diff_idx.tolist(), starts.tolist()):\n",
+    "                        if s_start + 1 < negative_input_ids.shape[1] - 1:\n",
+    "                            negative_input_ids[s_idx, s_start+1:] = \\\n",
+    "                                negative_input_ids[s_idx, s_start:-1].clone()\n",
+    "\n",
+    "                    correct_cnt[non_diff_idx] += 1\n",
+    "\n",
+    "                # ── SURGERY: Use Surgery Module for conditioning ──\n",
+    "                surgery_out = _run_surgery(outputs.hidden_states)       # [B, 1, 3584]\n",
+    "                positive_condition = surgery_out[:, -1, :][diffusion_indices]\n",
+    "\n",
+    "                neg_surgery_out = _run_surgery(negative_outputs.hidden_states)\n",
+    "                negative_condition = neg_surgery_out[:, -1, :][diffusion_indices]\n",
+    "\n",
+    "                speech_latent = self.sample_speech_tokens(\n",
+    "                    positive_condition,\n",
+    "                    negative_condition,\n",
+    "                    cfg_scale=cfg_scale,\n",
+    "                ).unsqueeze(1)\n",
+    "\n",
+    "                # Decode acoustic latent to audio\n",
+    "                scaled_latent = (\n",
+    "                    speech_latent\n",
+    "                    / self.model.speech_scaling_factor.to(speech_latent.device)\n",
+    "                    - self.model.speech_bias_factor.to(speech_latent.device)\n",
+    "                )\n",
+    "                audio_chunk = self.model.acoustic_tokenizer.decode(\n",
+    "                    scaled_latent.to(self.model.acoustic_tokenizer.device),\n",
+    "                    cache=acoustic_cache,\n",
+    "                    sample_indices=diffusion_indices.to(self.model.acoustic_tokenizer.device),\n",
+    "                    use_cache=True,\n",
+    "                    debug=False,\n",
+    "                )\n",
+    "\n",
+    "                for i, s_idx in enumerate(diffusion_indices):\n",
+    "                    idx = s_idx.item()\n",
+    "                    if not finished_tags[idx]:\n",
+    "                        audio_chunks[idx].append(audio_chunk[i])\n",
+    "\n",
+    "                if audio_streamer is not None:\n",
+    "                    audio_streamer.put(audio_chunk, diffusion_indices)\n",
+    "\n",
+    "                semantic_features = self.model.semantic_tokenizer.encode(\n",
+    "                    audio_chunk,\n",
+    "                    cache=semantic_cache,\n",
+    "                    sample_indices=diffusion_indices,\n",
+    "                    use_cache=True,\n",
+    "                    debug=False,\n",
+    "                ).mean\n",
+    "\n",
+    "                acoustic_embed = self.model.acoustic_connector(\n",
+    "                    speech_latent.to(acoustic_connect_device)\n",
+    "                ).to(device)\n",
+    "                semantic_embed = self.model.semantic_connector(\n",
+    "                    semantic_features.to(semantic_connect_device)\n",
+    "                ).to(device)\n",
+    "                diffusion_embeds = acoustic_embed + semantic_embed\n",
+    "\n",
+    "                next_inputs_embeds[diffusion_indices] = diffusion_embeds\n",
+    "\n",
+    "            inputs_embeds = next_inputs_embeds\n",
+    "\n",
+    "        if audio_streamer is not None:\n",
+    "            audio_streamer.end()\n",
+    "\n",
+    "        # Concatenate audio chunks\n",
+    "        final_audio_outputs = []\n",
+    "        for sample_chunks in audio_chunks:\n",
+    "            if sample_chunks:\n",
+    "                final_audio_outputs.append(torch.cat(sample_chunks, dim=-1))\n",
+    "            else:\n",
+    "                final_audio_outputs.append(None)\n",
+    "\n",
+    "        return VibeVoiceGenerationOutput(\n",
+    "            sequences=input_ids,\n",
+    "            speech_outputs=final_audio_outputs if return_speech else None,\n",
+    "            reach_max_step_sample=reach_max_step_sample,\n",
+    "        )\n",
+    "\n",
+    "    model.generate = types.MethodType(patched_generate, model)\n",
+    "    print(\"   ✓ Generate method patched (Surgery Module integrated)\")\n",
+    "\n",
+    "\n",
+    "print(\"✅ Generate patch function defined\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "---\n",
+    "## 7. Main Surgery Function\n",
+    "\n",
+    "The `perform_surgery()` function executes the complete model surgery on CPU:\n",
+    "1. Replace Qwen2.5-7B language model with Qwen3-4B\n",
+    "2. Replace acoustic & semantic connectors for new hidden size\n",
+    "3. Replace lm_head for new vocab size\n",
+    "4. Add Surgery Module\n",
+    "5. Patch forward methods\n",
+    "6. Update config"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def perform_surgery(\n",
+    "    vibevoice_model: VibeVoiceForConditionalGenerationInference,\n",
+    "    qwen3_model,\n",
+    "    surgery_layer_indices: Optional[List[int]] = None,\n",
+    "    dtype: torch.dtype = DTYPE,\n",
+    ") -> VibeVoiceForConditionalGenerationInference:\n",
+    "    \"\"\"\n",
+    "    Perform the complete model surgery on CPU:\n",
+    "      1. Replace Qwen2.5-7B language model with Qwen3-4B\n",
+    "      2. Replace acoustic & semantic connectors for new hidden size\n",
+    "      3. Replace lm_head for new vocab size\n",
+    "      4. Add Surgery Module\n",
+    "      5. Patch forward methods\n",
+    "      6. Update config\n",
+    "    \"\"\"\n",
+    "    if surgery_layer_indices is None:\n",
+    "        surgery_layer_indices = SURGERY_LAYER_INDICES\n",
+    "\n",
+    "    print(\"\\n\" + \"=\" * 64)\n",
+    "    print(\"  PERFORMING MODEL SURGERY (on CPU)\")\n",
+    "    print(\"=\" * 64)\n",
+    "\n",
+    "    # ── Step 1: Replace Language Model ──\n",
+    "    print(\"\\n[1/6] Replacing language model: Qwen2.5-7B → Qwen3-4B...\")\n",
+    "    qwen3_base = qwen3_model.model  # Qwen3Model (without lm_head)\n",
+    "\n",
+    "    old_lm = vibevoice_model.model.language_model\n",
+    "    del old_lm\n",
+    "    vibevoice_model.model.language_model = qwen3_base\n",
+    "    print(f\"   ✓ Language model replaced ({QWEN3_HIDDEN_SIZE}-dim, {QWEN3_NUM_LAYERS} layers)\")\n",
+    "\n",
+    "    # ── Step 2: Replace Acoustic Connector ──\n",
+    "    print(\"\\n[2/6] Replacing acoustic connector...\")\n",
+    "    old_acoustic = vibevoice_model.model.acoustic_connector\n",
+    "    del old_acoustic\n",
+    "    vibevoice_model.model.acoustic_connector = SpeechConnector(\n",
+    "        input_dim=vibevoice_model.config.acoustic_vae_dim,   # 64\n",
+    "        output_dim=QWEN3_HIDDEN_SIZE,                        # 2560\n",
+    "    ).to(dtype=dtype)\n",
+    "    print(f\"   ✓ Acoustic connector: 64 → {QWEN3_HIDDEN_SIZE}\")\n",
+    "\n",
+    "    # ── Step 3: Replace Semantic Connector ──\n",
+    "    print(\"\\n[3/6] Replacing semantic connector...\")\n",
+    "    old_semantic = vibevoice_model.model.semantic_connector\n",
+    "    del old_semantic\n",
+    "    vibevoice_model.model.semantic_connector = SpeechConnector(\n",
+    "        input_dim=vibevoice_model.config.semantic_vae_dim,   # 128\n",
+    "        output_dim=QWEN3_HIDDEN_SIZE,                        # 2560\n",
+    "    ).to(dtype=dtype)\n",
+    "    print(f\"   ✓ Semantic connector: 128 → {QWEN3_HIDDEN_SIZE}\")\n",
+    "\n",
+    "    # ── Step 4: Replace LM Head ──\n",
+    "    print(\"\\n[4/6] Replacing LM head...\")\n",
+    "    old_head = vibevoice_model.lm_head\n",
+    "    del old_head\n",
+    "    vibevoice_model.lm_head = nn.Linear(\n",
+    "        QWEN3_HIDDEN_SIZE, QWEN3_VOCAB_SIZE, bias=False\n",
+    "    ).to(dtype=dtype)\n",
+    "\n",
+    "    # Tie weights (Qwen3 uses tie_word_embeddings=True)\n",
+    "    if hasattr(vibevoice_model.model.language_model, \"embed_tokens\"):\n",
+    "        vibevoice_model.lm_head.weight = vibevoice_model.model.language_model.embed_tokens.weight\n",
+    "        print(\"   ✓ LM head weights tied to embed_tokens\")\n",
+    "    print(f\"   ✓ LM head: {QWEN3_HIDDEN_SIZE} → {QWEN3_VOCAB_SIZE}\")\n",
+    "\n",
+    "    # ── Step 5: Add Surgery Module ──\n",
+    "    print(\"\\n[5/6] Adding Surgery Module...\")\n",
+    "    surgery_module = Qwen3SurgeryModule(\n",
+    "        input_dim=QWEN3_HIDDEN_SIZE,\n",
+    "        output_dim=DIFFUSION_HIDDEN_SIZE,\n",
+    "        layer_indices=surgery_layer_indices,\n",
+    "        rms_norm_eps=1e-6,\n",
+    "    ).to(dtype=dtype)\n",
+    "    vibevoice_model.model.surgery_module = surgery_module\n",
+    "\n",
+    "    surgery_params = sum(p.numel() for p in surgery_module.parameters())\n",
+    "    print(f\"   ✓ Surgery Module: {surgery_params:,} parameters\")\n",
+    "    print(f\"   ✓ Pipeline: layers{surgery_layer_indices} → WeightedSum → \"\n",
+    "          f\"RMSNorm → SwiGLU → Linear({QWEN3_HIDDEN_SIZE}→{DIFFUSION_HIDDEN_SIZE})\")\n",
+    "\n",
+    "    # ── Step 6: Patch Forward Methods ──\n",
+    "    print(\"\\n[6/6] Patching forward & generate methods...\")\n",
+    "    _patch_base_model_forward(vibevoice_model.model)\n",
+    "    _patch_inference_forward(vibevoice_model)\n",
+    "    _patch_generate_method(vibevoice_model)\n",
+    "\n",
+    "    # ── Update Config ──\n",
+    "    print(\"\\n[Extra] Updating model config...\")\n",
+    "    _update_config_for_qwen3(vibevoice_model)\n",
+    "\n",
+    "    # ── Verify Diffusion Head untouched ──\n",
+    "    print(\"\\n[Verify] Diffusion Head (should be unchanged):\")\n",
+    "    dh = vibevoice_model.model.prediction_head\n",
+    "    print(f\"   cond_proj:          {dh.cond_proj.weight.shape}\")\n",
+    "    print(f\"   noisy_images_proj:  {dh.noisy_images_proj.weight.shape}\")\n",
+    "    print(f\"   hidden_size:        {dh.config.hidden_size}\")\n",
+    "\n",
+    "    print(\"\\n\" + \"=\" * 64)\n",
+    "    print(\"  SURGERY COMPLETE!\")\n",
+    "    print(\"=\" * 64)\n",
+    "\n",
+    "    return vibevoice_model\n",
+    "\n",
+    "\n",
+    "print(\"✅ Main surgery function defined\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "---\n",
+    "## 8. Custom Model Class for Save/Load\n",
+    "\n",
+    "Extended VibeVoice inference model that includes the Surgery Module in its `__init__`,\n",
+    "so `from_pretrained` can load surgery weights correctly."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import gc\n",
+    "import json\n",
+    "\n",
+    "\n",
+    "class VibeVoiceSurgeryModel(VibeVoiceForConditionalGenerationInference):\n",
+    "    \"\"\"\n",
+    "    Extended VibeVoice inference model that includes the Surgery Module\n",
+    "    in its __init__, so from_pretrained can load surgery weights correctly.\n",
+    "    \"\"\"\n",
+    "    \n",
+    "    def __init__(self, config):\n",
+    "        super().__init__(config)\n",
+    "        # Add surgery module if config includes it\n",
+    "        if hasattr(config, \"surgery_module_config\"):\n",
+    "            sc = config.surgery_module_config\n",
+    "            self.model.surgery_module = Qwen3SurgeryModule(\n",
+    "                input_dim=sc.get(\"input_dim\", QWEN3_HIDDEN_SIZE),\n",
+    "                output_dim=sc.get(\"output_dim\", DIFFUSION_HIDDEN_SIZE),\n",
+    "                layer_indices=sc.get(\"layer_indices\", SURGERY_LAYER_INDICES),\n",
+    "                rms_norm_eps=sc.get(\"rms_norm_eps\", 1e-6),\n",
+    "            )\n",
+    "\n",
+    "\n",
+    "# Register with AutoModel so from_pretrained works\n",
+    "AutoModelForCausalLM.register(VibeVoiceConfig, VibeVoiceSurgeryModel)\n",
+    "\n",
+    "print(\"✅ VibeVoiceSurgeryModel class defined and registered\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "---\n",
+    "## 9. Save & Load Functions"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def save_surgery_model(model, output_dir: str):\n",
+    "    \"\"\"\n",
+    "    Save the surgery model in a format that can be reloaded correctly.\n",
+    "    \n",
+    "    Key: We save decoder_config with model_type=\"qwen3\" and Qwen3 parameters.\n",
+    "    The monkey-patched VibeVoiceConfig handles qwen3 on reload.\n",
+    "    \"\"\"\n",
+    "    os.makedirs(output_dir, exist_ok=True)\n",
+    "    print(f\"  Saving model weights...\")\n",
+    "    model.save_pretrained(output_dir, safe_serialization=True)\n",
+    "    print(f\"  ✓ Model weights saved\")\n",
+    "\n",
+    "    # Save config with surgery_module_config\n",
+    "    print(f\"  Saving config...\")\n",
+    "    config_dict = model.config.to_dict()\n",
+    "    \n",
+    "    # Save decoder config as qwen3\n",
+    "    qwen3_cfg = create_qwen3_config_for_surgery()\n",
+    "    config_dict[\"decoder_config\"] = qwen3_cfg.to_dict()\n",
+    "    config_dict[\"decoder_config\"][\"model_type\"] = \"qwen3\"\n",
+    "\n",
+    "    # Add surgery module config\n",
+    "    config_dict[\"surgery_module_config\"] = {\n",
+    "        \"input_dim\": QWEN3_HIDDEN_SIZE,\n",
+    "        \"output_dim\": DIFFUSION_HIDDEN_SIZE,\n",
+    "        \"layer_indices\": SURGERY_LAYER_INDICES,\n",
+    "        \"rms_norm_eps\": 1e-6,\n",
+    "    }\n",
+    "\n",
+    "    config_path = os.path.join(output_dir, \"config.json\")\n",
+    "    with open(config_path, \"w\") as f:\n",
+    "        json.dump(config_dict, f, indent=2, default=str)\n",
+    "    print(f\"  ✓ Config saved\")\n",
+    "\n",
+    "    # Save surgery config separately\n",
+    "    surgery_config_path = os.path.join(output_dir, \"surgery_module_config.json\")\n",
+    "    with open(surgery_config_path, \"w\") as f:\n",
+    "        json.dump(config_dict[\"surgery_module_config\"], f, indent=2)\n",
+    "    print(f\"  ✓ Surgery module config saved\")\n",
+    "\n",
+    "    # Print file sizes\n",
+    "    print(f\"\\n  Saved files:\")\n",
+    "    total_size = 0\n",
+    "    for f_name in sorted(os.listdir(output_dir)):\n",
+    "        f_path = os.path.join(output_dir, f_name)\n",
+    "        if os.path.isfile(f_path):\n",
+    "            size_mb = os.path.getsize(f_path) / 1e6\n",
+    "            total_size += size_mb\n",
+    "            print(f\"    {f_name}: {size_mb:.1f} MB\")\n",
+    "    print(f\"  Total: {total_size:.1f} MB ({total_size/1024:.2f} GB)\")\n",
+    "    print(f\"  ✓ Saved to {output_dir}\")\n",
+    "\n",
+    "\n",
+    "def load_surgery_model(\n",
+    "    model_path: str,\n",
+    "    dtype: torch.dtype = DTYPE,\n",
+    "    device_map: str = \"auto\",\n",
+    "):\n",
+    "    \"\"\"\n",
+    "    Load a previously saved surgery model.\n",
+    "    \n",
+    "    Uses VibeVoiceSurgeryModel (custom class) so that from_pretrained\n",
+    "    creates the surgery_module before loading weights.\n",
+    "    \n",
+    "    Also applies the runtime forward/generate patches.\n",
+    "    \n",
+    "    Fix: When device_map=\"auto\", the auto-generated device map misses\n",
+    "    registered buffers (speech_scaling_factor, speech_bias_factor) that\n",
+    "    live directly on VibeVoiceModel. We manually add those entries.\n",
+    "    \"\"\"\n",
+    "    print(f\"\\n  Loading surgery model from {model_path}...\")\n",
+    "    \n",
+    "    # Ensure config patch is applied\n",
+    "    _patch_vibevoice_config_for_qwen3()\n",
+    "\n",
+    "    # Load config to get surgery_module_config\n",
+    "    config_path = os.path.join(model_path, \"config.json\")\n",
+    "    with open(config_path, \"r\") as f:\n",
+    "        config_dict = json.load(f)\n",
+    "\n",
+    "    # Create config using our patched VibeVoiceConfig\n",
+    "    config = VibeVoiceConfig(**config_dict)\n",
+    "\n",
+    "    # ── Fix device_map for registered buffers ──\n",
+    "    if device_map == \"auto\":\n",
+    "        from accelerate import infer_auto_device_map, get_max_memory\n",
+    "\n",
+    "        print(\"  Computing device map for multi-GPU placement...\")\n",
+    "        max_memory = get_max_memory()\n",
+    "\n",
+    "        # Build a meta-device model to infer the device map structure\n",
+    "        with torch.device(\"meta\"):\n",
+    "            meta_model = VibeVoiceSurgeryModel(config)\n",
+    "\n",
+    "        no_split = [\n",
+    "            \"VibeVoiceDiffusionHead\",\n",
+    "            \"VibeVoiceAcousticTokenizerModel\",\n",
+    "            \"VibeVoiceSemanticTokenizerModel\",\n",
+    "            \"Qwen3SurgeryModule\",\n",
+    "        ]\n",
+    "\n",
+    "        device_map_dict = infer_auto_device_map(\n",
+    "            meta_model,\n",
+    "            max_memory=max_memory,\n",
+    "            no_split_module_classes=no_split,\n",
+    "        )\n",
+    "\n",
+    "        # Determine which device to place the buffers on\n",
+    "        buffer_device = device_map_dict.get(\n",
+    "            \"model.language_model\",\n",
+    "            device_map_dict.get(\"model\", \"cuda:0\"),\n",
+    "        )\n",
+    "\n",
+    "        # Add entries for registered buffers that are direct children of model\n",
+    "        for key in [\"model.speech_scaling_factor\", \"model.speech_bias_factor\"]:\n",
+    "            if key not in device_map_dict:\n",
+    "                device_map_dict[key] = buffer_device\n",
+    "                print(f\"    Added device map entry: {key} → {buffer_device}\")\n",
+    "\n",
+    "        del meta_model\n",
+    "        gc.collect()\n",
+    "        torch.cuda.empty_cache()\n",
+    "\n",
+    "        device_map = device_map_dict\n",
+    "\n",
+    "    # Load using our custom class that includes surgery_module in __init__\n",
+    "    model = VibeVoiceSurgeryModel.from_pretrained(\n",
+    "        model_path,\n",
+    "        config=config,\n",
+    "        torch_dtype=dtype,\n",
+    "        device_map=device_map,\n",
+    "        trust_remote_code=True,\n",
+    "    )\n",
+    "\n",
+    "    # Verify surgery module\n",
+    "    if not hasattr(model.model, \"surgery_module\"):\n",
+    "        print(\"  ⚠  Surgery Module not found after loading, adding manually...\")\n",
+    "        sc = config.surgery_module_config\n",
+    "        model.model.surgery_module = Qwen3SurgeryModule(**sc).to(dtype=dtype)\n",
+    "        # Try to load surgery weights\n",
+    "        from safetensors.torch import load_file as safetensors_load\n",
+    "        safetensors_path = os.path.join(model_path, \"model.safetensors\")\n",
+    "        bin_path = os.path.join(model_path, \"pytorch_model.bin\")\n",
+    "        weights_path = safetensors_path if os.path.exists(safetensors_path) else bin_path\n",
+    "        if os.path.exists(weights_path):\n",
+    "            if weights_path.endswith(\".safetensors\"):\n",
+    "                all_weights = safetensors_load(weights_path)\n",
+    "            else:\n",
+    "                all_weights = torch.load(weights_path, map_location=\"cpu\")\n",
+    "            surgery_state = {\n",
+    "                k.replace(\"model.surgery_module.\", \"\"): v\n",
+    "                for k, v in all_weights.items()\n",
+    "                if k.startswith(\"model.surgery_module.\")\n",
+    "            }\n",
+    "            if surgery_state:\n",
+    "                model.model.surgery_module.load_state_dict(surgery_state, strict=False)\n",
+    "                print(\"  ✓ Surgery Module weights loaded\")\n",
+    "\n",
+    "    # Apply runtime patches (not saved with the model)\n",
+    "    _patch_base_model_forward(model.model)\n",
+    "    _patch_inference_forward(model)\n",
+    "    _patch_generate_method(model)\n",
+    "\n",
+    "    # Tie weights\n",
+    "    try:\n",
+    "        model.tie_weights()\n",
+    "    except Exception:\n",
+    "        pass\n",
+    "\n",
+    "    print(f\"  ✓ Surgery model loaded successfully\")\n",
+    "    return model\n",
+    "\n",
+    "\n",
+    "print(\"✅ Save/Load functions defined\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "---\n",
+    "## 10. Memory Estimation"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def estimate_memory():\n",
+    "    \"\"\"Print memory estimates for the surgery process.\"\"\"\n",
+    "    qwen3_gb = QWEN3_NUM_LAYERS * 0.22  # rough estimate ~8GB\n",
+    "    vibevoice_total_gb = 14.0  # ~7B params in fp16\n",
+    "    vibevoice_excl_lm_gb = 3.0  # diffusion head + tokenizers + connectors\n",
+    "    surgery_gb = 0.05  # ~25M params\n",
+    "    \n",
+    "    final_model_gb = qwen3_gb + vibevoice_excl_lm_gb + surgery_gb\n",
+    "    during_surgery_gb = vibevoice_total_gb + qwen3_gb\n",
+    "    \n",
+    "    print(f\"\\n📊 Memory Estimates (float16):\")\n",
+    "    print(f\"   VibeVoice 7B (CPU RAM):     ~{vibevoice_total_gb:.1f} GB\")\n",
+    "    print(f\"   Qwen3-4B (CPU RAM):         ~{qwen3_gb:.1f} GB\")\n",
+    "    print(f\"   During surgery (CPU RAM):   ~{during_surgery_gb:.1f} GB\")\n",
+    "    print(f\"   Final model (VRAM):         ~{final_model_gb:.1f} GB\")\n",
+    "    print(f\"   Colab CPU RAM available:    ~12-25 GB\")\n",
+    "    print(f\"   Colab GPU VRAM (T4):        15 GB\")\n",
+    "    print(f\"   ℹ  ️  If RAM is tight, load models sequentially (delete before loading next)\")\n",
+    "\n",
+    "\n",
+    "estimate_memory()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "---\n",
+    "## 11. Verification Tests"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def verify_surgery(model):\n",
+    "    \"\"\"Run verification tests on the modified model.\"\"\"\n",
+    "    print(\"\\n\" + \"─\" * 64)\n",
+    "    print(\"  VERIFICATION TESTS\")\n",
+    "    print(\"─\" * 64)\n",
+    "\n",
+    "    all_passed = True\n",
+    "\n",
+    "    # Test 1: Surgery Module exists\n",
+    "    print(\"\\n[Test 1] Surgery Module exists...\")\n",
+    "    try:\n",
+    "        assert hasattr(model.model, \"surgery_module\")\n",
+    "        sm = model.model.surgery_module\n",
+    "        assert sm.input_dim == QWEN3_HIDDEN_SIZE\n",
+    "        assert sm.output_dim == DIFFUSION_HIDDEN_SIZE\n",
+    "        assert sm.layer_indices == SURGERY_LAYER_INDICES\n",
+    "        print(\"  ✓ PASSED\")\n",
+    "    except Exception as e:\n",
+    "        print(f\"  ✗ FAILED: {e}\")\n",
+    "        all_passed = False\n",
+    "\n",
+    "    # Test 2: Language model is Qwen3\n",
+    "    print(\"\\n[Test 2] Language model is Qwen3...\")\n",
+    "    try:\n",
+    "        lm = model.model.language_model\n",
+    "        assert lm.config.hidden_size == QWEN3_HIDDEN_SIZE\n",
+    "        assert lm.config.num_hidden_layers == QWEN3_NUM_LAYERS\n",
+    "        print(f\"  ✓ PASSED (hidden={QWEN3_HIDDEN_SIZE}, layers={QWEN3_NUM_LAYERS})\")\n",
+    "    except Exception as e:\n",
+    "        print(f\"  ✗ FAILED: {e}\")\n",
+    "        all_passed = False\n",
+    "\n",
+    "    # Test 3: Connectors\n",
+    "    print(\"\\n[Test 3] Connector dimensions...\")\n",
+    "    try:\n",
+    "        ac = model.model.acoustic_connector\n",
+    "        sc = model.model.semantic_connector\n",
+    "        assert ac.fc1.out_features == QWEN3_HIDDEN_SIZE\n",
+    "        assert sc.fc1.out_features == QWEN3_HIDDEN_SIZE\n",
+    "        print(\"  ✓ PASSED\")\n",
+    "    except Exception as e:\n",
+    "        print(f\"  ✗ FAILED: {e}\")\n",
+    "        all_passed = False\n",
+    "\n",
+    "    # Test 4: LM Head\n",
+    "    print(\"\\n[Test 4] LM Head dimensions...\")\n",
+    "    try:\n",
+    "        assert model.lm_head.in_features == QWEN3_HIDDEN_SIZE\n",
+    "        assert model.lm_head.out_features == QWEN3_VOCAB_SIZE\n",
+    "        print(\"  ✓ PASSED\")\n",
+    "    except Exception as e:\n",
+    "        print(f\"  ✗ FAILED: {e}\")\n",
+    "        all_passed = False\n",
+    "\n",
+    "    # Test 5: Diffusion Head unchanged\n",
+    "    print(\"\\n[Test 5] Diffusion Head (should be 3584)...\")\n",
+    "    try:\n",
+    "        dh = model.model.prediction_head\n",
+    "        assert dh.config.hidden_size == DIFFUSION_HIDDEN_SIZE\n",
+    "        assert dh.cond_proj.weight.shape[0] == DIFFUSION_HIDDEN_SIZE\n",
+    "        assert dh.cond_proj.weight.shape[1] == DIFFUSION_HIDDEN_SIZE\n",
+    "        print(\"  ✓ PASSED\")\n",
+    "    except Exception as e:\n",
+    "        print(f\"  ✗ FAILED: {e}\")\n",
+    "        all_passed = False\n",
+    "\n",
+    "    # Test 6: Surgery Module forward pass\n",
+    "    print(\"\\n[Test 6] Surgery Module forward pass...\")\n",
+    "    try:\n",
+    "        sm = model.model.surgery_module\n",
+    "        device = next(sm.parameters()).device\n",
+    "        dtype = next(sm.parameters()).dtype\n",
+    "        with torch.no_grad():\n",
+    "            dummy_hs = tuple(\n",
+    "                torch.randn(1, 10, QWEN3_HIDDEN_SIZE, dtype=dtype, device=device)\n",
+    "                for _ in range(QWEN3_NUM_LAYERS + 1)\n",
+    "            )\n",
+    "            output = sm(dummy_hs)\n",
+    "            assert output.shape == (1, 10, DIFFUSION_HIDDEN_SIZE)\n",
+    "            assert not torch.isnan(output).any()\n",
+    "            assert not torch.isinf(output).any()\n",
+    "        print(f\"  ✓ PASSED [1, 10, {QWEN3_HIDDEN_SIZE}] → [1, 10, {DIFFUSION_HIDDEN_SIZE}]\")\n",
+    "    except Exception as e:\n",
+    "        print(f\"  ✗ FAILED: {e}\")\n",
+    "        all_passed = False\n",
+    "\n",
+    "    # Test 7: Layer weights uniform\n",
+    "    print(\"\\n[Test 7] Initial layer weights (uniform)...\")\n",
+    "    try:\n",
+    "        weights = F.softmax(sm.layer_weights, dim=0)\n",
+    "        expected = torch.full_like(weights, 1.0 / sm.num_layers)\n",
+    "        assert torch.allclose(weights, expected, atol=1e-6)\n",
+    "        print(f\"  ✓ PASSED ({weights.tolist()})\")\n",
+    "    except Exception as e:\n",
+    "        print(f\"  ✗ FAILED: {e}\")\n",
+    "        all_passed = False\n",
+    "\n",
+    "    # Test 8: Output projection zero-init\n",
+    "    print(\"\\n[Test 8] Output projection zero-init...\")\n",
+    "    try:\n",
+    "        assert torch.all(sm.output_proj.weight == 0)\n",
+    "        print(\"  ✓ PASSED\")\n",
+    "    except Exception as e:\n",
+    "        print(f\"  ✗ FAILED: {e}\")\n",
+    "        all_passed = False\n",
+    "\n",
+    "    print(\"\\n\" + \"─\" * 64)\n",
+    "    if all_passed:\n",
+    "        print(\"  ✅ ALL TESTS PASSED!\")\n",
+    "    else:\n",
+    "        print(\"  ⚠️  SOME TESTS FAILED — check above\")\n",
+    "    print(\"─\" * 64)\n",
+    "\n",
+    "    return all_passed\n",
+    "\n",
+    "\n",
+    "def print_surgery_summary(model):\n",
+    "    \"\"\"Print a comprehensive summary of the surgery model.\"\"\"\n",
+    "    print(\"\\n\" + \"═\" * 64)\n",
+    "    print(\"  SURGERY SUMMARY\")\n",
+    "    print(\"═\" * 64)\n",
+    "\n",
+    "    lm = model.model.language_model\n",
+    "    lm_params = sum(p.numel() for p in lm.parameters())\n",
+    "    print(f\"\\n┌─ Language Model (Qwen3-4B)\")\n",
+    "    print(f\"│  Type:       {lm.__class__.__name__}\")\n",
+    "    print(f\"│  Parameters: {lm_params:,}\")\n",
+    "    print(f\"│  Hidden:     {model.config.decoder_config.hidden_size}\")\n",
+    "    print(f\"│  Layers:     {model.config.decoder_config.num_hidden_layers}\")\n",
+    "\n",
+    "    sm = model.model.surgery_module\n",
+    "    sm_params = sum(p.numel() for p in sm.parameters())\n",
+    "    print(f\"├─ Surgery Module\")\n",
+    "    print(f\"│  Parameters: {sm_params:,}\")\n",
+    "    print(f\"│  {sm.extra_repr()}\")\n",
+    "\n",
+    "    ac_params = sum(p.numel() for p in model.model.acoustic_connector.parameters())\n",
+    "    sc_params = sum(p.numel() for p in model.model.semantic_connector.parameters())\n",
+    "    print(f\"├─ Acoustic Connector: {ac_params:,} params\")\n",
+    "    print(f\"├─ Semantic Connector: {sc_params:,} params\")\n",
+    "\n",
+    "    lmh_params = sum(p.numel() for p in model.lm_head.parameters())\n",
+    "    print(f\"├─ LM Head: {lmh_params:,} params\")\n",
+    "\n",
+    "    dh = model.model.prediction_head\n",
+    "    dh_params = sum(p.numel() for p in dh.parameters())\n",
+    "    print(f\"├─ Diffusion Head (unchanged): {dh_params:,} params\")\n",
+    "\n",
+    "    at_params = sum(p.numel() for p in model.model.acoustic_tokenizer.parameters())\n",
+    "    st_params = sum(p.numel() for p in model.model.semantic_tokenizer.parameters())\n",
+    "    print(f\"├─ Acoustic Tokenizer (unchanged): {at_params:,} params\")\n",
+    "    print(f\"└─ Semantic Tokenizer (unchanged): {st_params:,} params\")\n",
+    "\n",
+    "    total_params = sum(p.numel() for p in model.parameters())\n",
+    "    print(f\"\\n  Total: {total_params:,} params (~{total_params * 2 / 1e9:.2f} GB in fp16)\")\n",
+    "\n",
+    "    print(f\"\\n  Data Flow:\")\n",
+    "    print(f\"  Audio → AcousticTokenizer → (64-dim) → AcousticConnector → ({QWEN3_HIDDEN_SIZE}-dim)\")\n",
+    "    print(f\"  Audio → SemanticTokenizer → (128-dim) → SemanticConnector → ({QWEN3_HIDDEN_SIZE}-dim)\")\n",
+    "    print(f\"  Combined → Qwen3-4B → hidden_states[37 × {QWEN3_HIDDEN_SIZE}-dim]\")\n",
+    "    print(f\"  → SurgeryModule → ({DIFFUSION_HIDDEN_SIZE}-dim) → DiffusionHead → Speech\")\n",
+    "    print(f\"  → LMHead → Text Tokens\")\n",
+    "    print(\"═\" * 64)\n",
+    "\n",
+    "\n",
+    "print(\"✅ Verification and summary functions defined\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "---\n",
+    "## 12. Main Surgery Pipeline\n",
+    "\n",
+    "Execute the complete surgery:\n",
+    "1. Load VibeVoice 7B on CPU\n",
+    "2. Load Qwen3-4B on CPU\n",
+    "3. Perform surgery on CPU\n",
+    "4. Save modified model\n",
+    "5. Reload with device_map across GPU(s)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def run_surgery():\n",
+    "    \"\"\"\n",
+    "    Execute the complete surgery pipeline:\n",
+    "      1. Load VibeVoice 7B on CPU\n",
+    "      2. Load Qwen3-4B on CPU\n",
+    "      3. Perform surgery on CPU\n",
+    "      4. Save modified model\n",
+    "      5. Reload with device_map across GPU(s)\n",
+    "    \"\"\"\n",
+    "    print(\"\\n\" + \"█\" * 64)\n",
+    "    print(\"  VIBEVOICE MODEL SURGERY\")\n",
+    "    print(\"  Qwen2.5-7B → Qwen3-4B + Surgery Module\")\n",
+    "    print(\"█\" * 64)\n",
+    "\n",
+    "    estimate_memory()\n",
+    "\n",
+    "    # ── Step 1: Load VibeVoice 7B on CPU ──\n",
+    "    print(\"\\n[Step 1/5] Loading VibeVoice 7B on CPU...\")\n",
+    "    gc.collect()\n",
+    "    torch.cuda.empty_cache()\n",
+    "\n",
+    "    try:\n",
+    "        vibevoice_model = VibeVoiceForConditionalGenerationInference.from_pretrained(\n",
+    "            VIBEVOICE_MODEL_ID,\n",
+    "            torch_dtype=DTYPE,\n",
+    "            device_map=\"cpu\",\n",
+    "            trust_remote_code=True,\n",
+    "        )\n",
+    "        print(f\"  ✓ VibeVoice 7B loaded on CPU\")\n",
+    "    except Exception as e:\n",
+    "        print(f\"  ✗ Failed: {e}\")\n",
+    "        raise\n",
+    "\n",
+    "    print(f\"  Original decoder: {vibevoice_model.config.decoder_config.hidden_size}-dim, \"\n",
+    "          f\"{vibevoice_model.config.decoder_config.num_hidden_layers} layers, \"\n",
+    "          f\"vocab={vibevoice_model.config.decoder_config.vocab_size}\")\n",
+    "\n",
+    "    # ── Step 2: Load Qwen3-4B on CPU ──\n",
+    "    print(f\"\\n[Step 2/5] Loading {QWEN3_MODEL_ID} on CPU...\")\n",
+    "    gc.collect()\n",
+    "    torch.cuda.empty_cache()\n",
+    "\n",
+    "    try:\n",
+    "        qwen3_model = AutoModelForCausalLM.from_pretrained(\n",
+    "            QWEN3_MODEL_ID,\n",
+    "            torch_dtype=DTYPE,\n",
+    "            device_map=\"cpu\",\n",
+    "            trust_remote_code=True,\n",
+    "        )\n",
+    "        print(f\"  ✓ Qwen3-4B loaded on CPU\")\n",
+    "    except Exception as e:\n",
+    "        print(f\"  ✗ Failed: {e}\")\n",
+    "        print(f\"  ℹ  ️  Ensure transformers>=4.51.0: pip install 'transformers>=4.51.0'\")\n",
+    "        raise\n",
+    "\n",
+    "    # Verify dimensions\n",
+    "    assert qwen3_model.config.hidden_size == QWEN3_HIDDEN_SIZE\n",
+    "    assert qwen3_model.config.num_hidden_layers == QWEN3_NUM_LAYERS\n",
+    "    assert qwen3_model.config.vocab_size == QWEN3_VOCAB_SIZE\n",
+    "    print(f\"  Qwen3: {QWEN3_HIDDEN_SIZE}-dim, {QWEN3_NUM_LAYERS} layers, vocab={QWEN3_VOCAB_SIZE}\")\n",
+    "\n",
+    "    # ── Step 3: Perform Surgery on CPU ──\n",
+    "    print(f\"\\n[Step 3/5] Performing surgery on CPU...\")\n",
+    "    modified_model = perform_surgery(\n",
+    "        vibevoice_model=vibevoice_model,\n",
+    "        qwen3_model=qwen3_model,\n",
+    "        surgery_layer_indices=SURGERY_LAYER_INDICES,\n",
+    "        dtype=DTYPE,\n",
+    "    )\n",
+    "\n",
+    "    # Free Qwen3 model\n",
+    "    del qwen3_model\n",
+    "    gc.collect()\n",
+    "    torch.cuda.empty_cache()\n",
+    "\n",
+    "    # ── Step 4: Save Surgery Model ──\n",
+    "    print(f\"\\n[Step 4/5] Saving surgery model to {OUTPUT_DIR}...\")\n",
+    "    save_surgery_model(modified_model, OUTPUT_DIR)\n",
+    "\n",
+    "    # Free CPU model\n",
+    "    del modified_model\n",
+    "    gc.collect()\n",
+    "    torch.cuda.empty_cache()\n",
+    "\n",
+    "    # ── Step 5: Reload with device_map ──\n",
+    "    print(f\"\\n[Step 5/5] Loading with device_map across GPU(s)...\")\n",
+    "    final_model = load_surgery_model(\n",
+    "        OUTPUT_DIR,\n",
+    "        dtype=DTYPE,\n",
+    "        device_map=\"auto\",\n",
+    "    )\n",
+    "\n",
+    "    # Print summary\n",
+    "    print_surgery_summary(final_model)\n",
+    "\n",
+    "    return final_model\n",
+    "\n",
+    "\n",
+    "print(\"✅ Main surgery pipeline defined\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "---\n",
+    "## 13. 🚀 Run the Surgery!\n",
+    "\n",
+    "**⚠️ Important Notes Before Running:**\n",
+    "1. This will download ~22 GB of model weights (VibeVoice 7B + Qwen3-4B)\n",
+    "2. The surgery is performed on CPU to avoid GPU OOM\n",
+    "3. The final model is saved and reloaded with `device_map=\"auto\"`\n",
+    "4. Make sure you have enough disk space (~25 GB) and RAM (~25 GB)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# ╔═══════════════════════════════════════════════════════════════╗\n",
+    "# ║           RUN THE SURGERY — Execute this cell!               ║\n",
+    "# ╚═══════════════════════════════════════════════════════════════╝\n",
+    "\n",
+    "surgery_model = run_surgery()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "---\n",
+    "## 14. Verify the Surgery"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Run verification tests\n",
+    "all_tests_passed = verify_surgery(surgery_model)\n",
+    "print(f\"\\nVerification result: {'✅ ALL PASSED' if all_tests_passed else '❌ SOME FAILED'}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "---\n",
+    "## 15. Tokenizer Setup (Required for Inference)\n",
+    "\n",
+    "Qwen3 has a different vocabulary than Qwen2.5:\n",
+    "- Qwen2.5 vocab_size: 152064\n",
+    "- Qwen3 vocab_size: 151936\n",
+    "\n",
+    "You must use the Qwen3 tokenizer and add the special speech tokens."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Load Qwen3 tokenizer\n",
+    "from transformers import AutoTokenizer\n",
+    "\n",
+    "qwen3_tokenizer = AutoTokenizer.from_pretrained(QWEN3_MODEL_ID, trust_remote_code=True)\n",
+    "print(f\"Qwen3 tokenizer loaded: vocab_size={qwen3_tokenizer.vocab_size}\")\n",
+    "\n",
+    "# Load original VibeVoice tokenizer to get special token IDs\n",
+    "from vibevoice.processor.vibevoice_processor import VibeVoiceProcessor\n",
+    "orig_processor = VibeVoiceProcessor.from_pretrained(VIBEVOICE_MODEL_ID)\n",
+    "orig_tokenizer = orig_processor.tokenizer\n",
+    "\n",
+    "# Get special token values from original tokenizer\n",
+    "special_tokens = {\n",
+    "    \"speech_start\": getattr(orig_tokenizer, \"speech_start_id\", None),\n",
+    "    \"speech_end\": getattr(orig_tokenizer, \"speech_end_id\", None),\n",
+    "    \"speech_diffusion\": getattr(orig_tokenizer, \"speech_diffusion_id\", None),\n",
+    "}\n",
+    "print(f\"\\nOriginal special tokens: {special_tokens}\")\n",
+    "print(f\"Original speech_start decoded: '{orig_tokenizer.decode([special_tokens['speech_start']])}'\")\n",
+    "print(f\"Original speech_end decoded: '{orig_tokenizer.decode([special_tokens['speech_end']])}'\")\n",
+    "print(f\"Original speech_diffusion decoded: '{orig_tokenizer.decode([special_tokens['speech_diffusion']])}'\")\n",
+    "\n",
+    "# Add special tokens to Qwen3 tokenizer\n",
+    "num_added = qwen3_tokenizer.add_special_tokens({\n",
+    "    \"additional_special_tokens\": [\n",
+    "        orig_tokenizer.decode([special_tokens[\"speech_start\"]]),\n",
+    "        orig_tokenizer.decode([special_tokens[\"speech_end\"]]),\n",
+    "        orig_tokenizer.decode([special_tokens[\"speech_diffusion\"]]),\n",
+    "    ]\n",
+    "})\n",
+    "print(f\"\\nAdded {num_added} special tokens to Qwen3 tokenizer\")\n",
+    "\n",
+    "# Get new IDs\n",
+    "qwen3_tokenizer.speech_start_id = qwen3_tokenizer.convert_tokens_to_ids(\n",
+    "    orig_tokenizer.decode([special_tokens[\"speech_start\"]])\n",
+    ")\n",
+    "qwen3_tokenizer.speech_end_id = qwen3_tokenizer.convert_tokens_to_ids(\n",
+    "    orig_tokenizer.decode([special_tokens[\"speech_end\"]])\n",
+    ")\n",
+    "qwen3_tokenizer.speech_diffusion_id = qwen3_tokenizer.convert_tokens_to_ids(\n",
+    "    orig_tokenizer.decode([special_tokens[\"speech_diffusion\"]])\n",
+    ")\n",
+    "\n",
+    "print(f\"\\nNew special token IDs:\")\n",
+    "print(f\"  speech_start_id:      {qwen3_tokenizer.speech_start_id}\")\n",
+    "print(f\"  speech_end_id:        {qwen3_tokenizer.speech_end_id}\")\n",
+    "print(f\"  speech_diffusion_id:  {qwen3_tokenizer.speech_diffusion_id}\")\n",
+    "\n",
+    "# Resize model embeddings if needed\n",
+    "new_vocab_size = len(qwen3_tokenizer)\n",
+    "print(f\"\\nNew vocab size: {new_vocab_size}\")\n",
+    "\n",
+    "if new_vocab_size != surgery_model.config.decoder_config.vocab_size:\n",
+    "    print(f\"Resizing embeddings: {surgery_model.config.decoder_config.vocab_size} → {new_vocab_size}\")\n",
+    "    surgery_model.model.language_model.resize_token_embeddings(new_vocab_size)\n",
+    "    surgery_model.config.decoder_config.vocab_size = new_vocab_size\n",
+    "    # Re-tie weights\n",
+    "    surgery_model.lm_head.weight = surgery_model.model.language_model.embed_tokens.weight\n",
+    "    print(\"  ✓ Embeddings resized and weights re-tied\")\n",
+    "\n",
+    "print(\"\\n✅ Tokenizer setup complete\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "---\n",
+    "## 16. Inference Demo\n",
+    "\n",
+    "Test the surgery model with a simple text-to-speech generation.\n",
+    "\n",
+    "**Note:** The surgery model is in its initial state (zero-init output projection),\n",
+    "so the generated speech quality will be random noise. You need to **fine-tune** the\n",
+    "surgery module + connectors for meaningful output."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Test inference (expect random noise since model is not fine-tuned yet)\n",
+    "import numpy as np\n",
+    "\n",
+    "print(\"Testing inference (random output expected — fine-tune for real speech)...\\n\")\n",
+    "\n",
+    "# Prepare input\n",
+    "text = \"Hello, this is a test of the surgery model.\"\n",
+    "\n",
+    "# Use the processor to format the input\n",
+    "processor = VibeVoiceProcessor.from_pretrained(VIBEVOICE_MODEL_ID)\n",
+    "# Update processor's tokenizer\n",
+    "processor.tokenizer = qwen3_tokenizer\n",
+    "\n",
+    "# Format input with speech markers\n",
+    "formatted_text = f\"<|speech_start|>{text}<|speech_diffusion|>\"\n",
+    "input_ids = qwen3_tokenizer.encode(formatted_text, return_tensors=\"pt\")\n",
+    "\n",
+    "# Create speech masks (dummy for testing)\n",
+    "speech_tensors = torch.zeros(1, 1, 64, dtype=DTYPE, device=surgery_model.device)\n",
+    "speech_masks = torch.ones(1, 1, dtype=torch.bool)\n",
+    "speech_input_mask = torch.zeros_like(input_ids, dtype=torch.bool)\n",
+    "\n",
+    "print(f\"Input text: {text}\")\n",
+    "print(f\"Formatted: {formatted_text}\")\n",
+    "print(f\"Input IDs shape: {input_ids.shape}\")\n",
+    "print(f\"\\nGenerating...\")\n",
+    "\n",
+    "try:\n",
+    "    with torch.no_grad():\n",
+    "        output = surgery_model.generate(\n",
+    "            input_ids=input_ids.to(surgery_model.device),\n",
+    "            tokenizer=qwen3_tokenizer,\n",
+    "            speech_tensors=speech_tensors,\n",
+    "            speech_masks=speech_masks,\n",
+    "            speech_input_mask=speech_input_mask,\n",
+    "            max_new_tokens=50,\n",
+    "            do_sample=False,\n",
+    "            return_speech=True,\n",
+    "            show_progress_bar=True,\n",
+    "        )\n",
+    "    \n",
+    "    print(f\"\\n✅ Inference completed!\")\n",
+    "    print(f\"Generated sequence length: {output.sequences.shape[-1]}\")\n",
+    "    if output.speech_outputs and output.speech_outputs[0] is not None:\n",
+    "        print(f\"Speech output shape: {output.speech_outputs[0].shape}\")\n",
+    "        # Save as audio file\n",
+    "        import scipy.io.wavfile as wavfile\n",
+    "        audio = output.speech_outputs[0].cpu().numpy().squeeze()\n",
+    "        wavfile.write(\"/content/surgery_test_output.wav\", 24000, audio)\n",
+    "        print(f\"Audio saved to /content/surgery_test_output.wav\")\n",
+    "    else:\n",
+    "        print(\"No speech output (expected for un-fine-tuned model)\")\n",
+    "except Exception as e:\n",
+    "    print(f\"Inference error (expected for un-fine-tuned model): {e}\")\n",
+    "    print(\"This is normal — the surgery module needs fine-tuning before generating real speech.\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "---\n",
+    "## 17. LoRA Fine-Tuning Setup (Optional)\n",
+    "\n",
+    "Setup LoRA for parameter-efficient fine-tuning of the surgery model."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def setup_lora_training(\n",
+    "    model,\n",
+    "    lora_r: int = 16,\n",
+    "    lora_alpha: int = 32,\n",
+    "    lora_dropout: float = 0.05,\n",
+    "    target_modules: Optional[List[str]] = None,\n",
+    "):\n",
+    "    \"\"\"\n",
+    "    Setup LoRA for parameter-efficient fine-tuning of the surgery model.\n",
+    "    \"\"\"\n",
+    "    try:\n",
+    "        from peft import LoraConfig, get_peft_model, TaskType\n",
+    "    except ImportError:\n",
+    "        raise ImportError(\"pip install peft\")\n",
+    "\n",
+    "    if target_modules is None:\n",
+    "        target_modules = [\n",
+    "            \"surgery_module.swiglu_gate\",\n",
+    "            \"surgery_module.swiglu_up\",\n",
+    "            \"surgery_module.output_proj\",\n",
+    "            \"acoustic_connector.fc1\",\n",
+    "            \"acoustic_connector.fc2\",\n",
+    "            \"semantic_connector.fc1\",\n",
+    "            \"semantic_connector.fc2\",\n",
+    "        ]\n",
+    "\n",
+    "    lora_config = LoraConfig(\n",
+    "        r=lora_r,\n",
+    "        lora_alpha=lora_alpha,\n",
+    "        lora_dropout=lora_dropout,\n",
+    "        target_modules=target_modules,\n",
+    "        bias=\"none\",\n",
+    "        task_type=TaskType.CAUSAL_LM,\n",
+    "    )\n",
+    "\n",
+    "    peft_model = get_peft_model(model, lora_config)\n",
+    "\n",
+    "    trainable = sum(p.numel() for p in peft_model.parameters() if p.requires_grad)\n",
+    "    total = sum(p.numel() for p in peft_model.parameters())\n",
+    "    print(f\"\\n  LoRA Applied:\")\n",
+    "    print(f\"  Trainable: {trainable:,} ({100 * trainable / total:.2f}%)\")\n",
+    "    print(f\"  Total:     {total:,}\")\n",
+    "\n",
+    "    return peft_model\n",
+    "\n",
+    "\n",
+    "# Uncomment to apply LoRA:\n",
+    "# lora_model = setup_lora_training(surgery_model)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "---\n",
+    "## 18. Push to HuggingFace Hub (Optional)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Uncomment and set your HF token to push the model\n",
+    "# from huggingface_hub import login\n",
+    "# login(token=\"YOUR_HF_TOKEN\")\n",
+    "#\n",
+    "# HF_REPO = \"your-username/vibevoice-qwen3-surgery\"\n",
+    "# surgery_model.push_to_hub(HF_REPO)\n",
+    "# qwen3_tokenizer.push_to_hub(HF_REPO)\n",
+    "# print(f\"Model pushed to https://huggingface.co/{HF_REPO}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "---\n",
+    "## 19. Load from Saved Checkpoint (Future Use)\n",
+    "\n",
+    "To reload the surgery model later without re-running the surgery:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Uncomment to load from saved checkpoint:\n",
+    "# _patch_vibevoice_config_for_qwen3()\n",
+    "# loaded_model = load_surgery_model(\n",
+    "#     OUTPUT_DIR,\n",
+    "#     dtype=DTYPE,\n",
+    "#     device_map=\"auto\",\n",
+    "# )\n",
+    "# verify_surgery(loaded_model)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "---\n",
+    "## 20. Compatibility Notes\n",
+    "\n",
+    "### ✅ Compatible (no changes needed):\n",
+    "- `VibeVoiceModel` — forward patched to force `output_hidden_states=True`\n",
+    "- `SpeechConnector` — replaced with correct dimensions (64/128 → 2560)\n",
+    "- `VibeVoiceDiffusionHead` — UNCHANGED (still expects 3584-dim conditioning)\n",
+    "- `VibeVoiceAcousticTokenizerModel` — UNCHANGED\n",
+    "- `VibeVoiceSemanticTokenizerModel` — UNCHANGED\n",
+    "- `VibeVoiceTokenizerStreamingCache` — UNCHANGED\n",
+    "- `AudioStreamer` / `AsyncAudioStreamer` — UNCHANGED\n",
+    "- `DPMSolverMultistepScheduler` — UNCHANGED\n",
+    "- `sample_speech_tokens()` — UNCHANGED (receives 3584-dim from surgery)\n",
+    "\n",
+    "### ⚠️ Requires Attention:\n",
+    "1. **TOKENIZER**: Qwen3 has `vocab_size=151936` (vs Qwen2's 152064). You MUST swap the text tokenizer to `Qwen3Tokenizer`.\n",
+    "\n",
+    "2. **SPECIAL TOKENS**: `speech_start_id`, `speech_end_id`, `speech_diffusion_id` must be added to the Qwen3 tokenizer.\n",
+    "\n",
+    "3. **TRAINING**: Use `finetune_vibevoice_lora105.py` with `--train_surgery_module=True` for fine-tuning.\n",
+    "\n",
+    "4. **CONFIG LOADING**: Call `_patch_vibevoice_config_for_qwen3()` before loading the saved model.\n",
+    "\n",
+    "5. **WEIGHT TYING**: Qwen3 uses `tie_word_embeddings=True`. After surgery, `lm_head.weight` IS `embed_tokens.weight`.\n",
+    "\n",
+    "6. **GENERATE**: Each `generate()` call is independent. The surgery module is called fresh for each diffusion step.\n",
+    "\n",
+    "7. **MULTI-GPU**: The patched generate method handles device placement for multi-GPU setups."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "print(\"\\n\" + \"█\" * 64)\n",
+    "print(\"  SURGERY NOTEBOOK COMPLETE!\")\n",
+    "print(f\"  Model saved to: {OUTPUT_DIR}\")\n",
+    "print(\"\")\n",
+    "print(\"  Next Steps:\")\n",
+    "print(\"  1. Fine-tune the Surgery Module + connectors\")\n",
+    "print(\"  2. Use setup_lora_training() for LoRA fine-tuning\")\n",
+    "print(\"  3. Use load_surgery_model() to reload later\")\n",
+    "print(\"  4. Use finetune_vibevoice_lora105.py with --train_surgery_module=True\")\n",
+    "print(\"█\" * 64)"
+   ]
+  }
+ ]
+}

VibeVoice-tpu/src/vibevoice_surgery_colab.py

@@ -0,0 +1,1631 @@
+"""
+VibeVoice Surgery for Kaggle Dual T4 GPUs
+==========================================
+
+This script performs model surgery on VibeVoice-7B, replacing the Qwen2.5-7B
+language model with Qwen3-4B and adding a Surgery Module to bridge the hidden
+dimension gap (2560 → 3584) for the Diffusion Head.
+
+Designed for Kaggle environment:
+  - 2× T4 GPUs (16 GB VRAM each, 32 GB total)
+  - ~30 GB system RAM (CPU)
+  - float16 precision (T4 native — bfloat16 is NOT efficient on Turing arch.)
+
+Memory strategy:
+  1. Load both models on CPU RAM (~22 GB in fp16)
+  2. Perform surgery on CPU
+  3. Save the modified model
+  4. Reload with device_map="auto" across both T4 GPUs
+
+Compatibility fixes vs. the original surgery script:
+  - Monkey-patches VibeVoiceConfig to accept Qwen3Config
+  - Saves config in a reload-safe format (Qwen3 params under qwen2 model_type)
+  - Adds hidden_states to inference forward output (needed by surgery module)
+  - Uses float16 for T4 compatibility
+  - Handles device placement for multi-GPU surgery module calls
+  - Properly ties LM head weights for Qwen3
+"""
+
+import os
+import sys
+import gc
+import json
+import copy
+import types
+import warnings
+import functools
+from typing import Optional, Tuple, Union, List, Dict, Any
+from dataclasses import dataclass
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+from transformers import (
+    AutoModel,
+    AutoModelForCausalLM,
+    AutoConfig,
+    AutoTokenizer,
+)
+from transformers.modeling_outputs import BaseModelOutputWithPast, ModelOutput
+from transformers.models.llama.modeling_llama import LlamaRMSNorm
+from transformers.utils import logging
+
+# ── Import VibeVoice components ──
+from vibevoice.modular.configuration_vibevoice import (
+    VibeVoiceConfig,
+    VibeVoiceDiffusionHeadConfig,
+)
+from vibevoice.modular.modeling_vibevoice import (
+    VibeVoiceModel,
+    VibeVoiceForConditionalGeneration,
+    SpeechConnector,
+)
+from vibevoice.modular.modeling_vibevoice_inference import (
+    VibeVoiceForConditionalGenerationInference,
+    VibeVoiceCausalLMOutputWithPast,
+    VibeVoiceGenerationOutput,
+    VibeVoiceTokenConstraintProcessor,
+)
+from vibevoice.modular.modular_vibevoice_tokenizer import VibeVoiceTokenizerStreamingCache
+
+logger = logging.get_logger(__name__)
+
+# ============================================================================
+# SECTION 1: Global Configuration
+# ============================================================================
+
+DTYPE = torch.float16  # T4 native precision (NOT bfloat16)
+
+# Qwen3-4B dimensions
+QWEN3_HIDDEN_SIZE = 2560
+QWEN3_NUM_LAYERS = 36
+QWEN3_VOCAB_SIZE = 151936
+QWEN3_MODEL_ID = "Qwen/Qwen3-4B-Instruct-2507"
+
+# VibeVoice Diffusion Head dimensions (unchanged)
+DIFFUSION_HIDDEN_SIZE = 3584
+
+# Surgery: which intermediate layers of Qwen3 to extract (0-indexed)
+# Layers 24, 28, 32, 34 out of 36 total
+SURGERY_LAYER_INDICES = [24, 28, 32, 34]
+
+# Attention implementation
+# IMPORTANT: T4 GPUs (Turing architecture) do NOT support flash_attention_2.
+# Always use "sdpa" for T4 / Turing compatibility.
+ATTN_IMPL = "sdpa"
+
+# Model paths — adjust for your setup
+VIBEVOICE_MODEL_ID = "vibevoice/VibeVoice-7B"
+OUTPUT_DIR = "/kaggle/working/vibevoice_qwen3_surgery"
+
+print(f"╔══════════════════════════════════════════════════════════════╗")
+print(f"║  VibeVoice Surgery — Kaggle Dual T4 Configuration           ║")
+print(f"╠══════════════════════════════════════════════════════════════╣")
+print(f"║  Dtype:            {str(DTYPE):<42}║")
+print(f"║  Attention:        {ATTN_IMPL:<42}║")
+print(f"║  Qwen3 hidden:     {QWEN3_HIDDEN_SIZE:<42}║")
+print(f"║  Qwen3 layers:     {QWEN3_NUM_LAYERS:<42}║")
+print(f"║  Diffusion hidden: {DIFFUSION_HIDDEN_SIZE:<42}║")
+print(f"║  Surgery layers:   {str(SURGERY_LAYER_INDICES):<42}║")
+print(f"╚══════════════════════════════════════════════════════════════╝")
+
+
+# ============================================================================
+# SECTION 2: Monkey-patch VibeVoiceConfig to Accept Qwen3
+# ============================================================================
+
+def _patch_vibevoice_config_for_qwen3():
+    """
+    Monkey-patch VibeVoiceConfig.__init__ to accept Qwen3Config as decoder_config.
+    
+    The original VibeVoiceConfig only accepts decoder_config with model_type="qwen2".
+    This patch adds support for model_type="qwen3" by importing Qwen3Config and
+    handling it alongside Qwen2Config.
+    """
+    try:
+        from transformers import Qwen3Config
+    except ImportError:
+        raise ImportError(
+            "Qwen3Config not found. Please upgrade transformers: "
+            "pip install 'transformers>=4.51.0'"
+        )
+    
+    from transformers.models.qwen2.configuration_qwen2 import Qwen2Config
+    from transformers.configuration_utils import PretrainedConfig
+    
+    # Store original __init__ for reference
+    _orig_init = VibeVoiceConfig.__init__
+    
+    def _new_init(
+        self,
+        acoustic_tokenizer_config=None,
+        semantic_tokenizer_config=None,
+        decoder_config=None,
+        diffusion_head_config=None,
+        **kwargs
+    ):
+        kwargs["_attn_implementation_autoset"] = False
+        
+        # ── acoustic_tokenizer_config ──
+        if acoustic_tokenizer_config is None:
+            self.acoustic_tokenizer_config = self.sub_configs["acoustic_tokenizer_config"]()
+        elif isinstance(acoustic_tokenizer_config, dict):
+            acoustic_tokenizer_config["model_type"] = "vibevoice_acoustic_tokenizer"
+            self.acoustic_tokenizer_config = self.sub_configs["acoustic_tokenizer_config"](
+                **acoustic_tokenizer_config
+            )
+        else:
+            self.acoustic_tokenizer_config = acoustic_tokenizer_config
+        
+        # ── semantic_tokenizer_config ──
+        if semantic_tokenizer_config is None:
+            self.semantic_tokenizer_config = self.sub_configs["semantic_tokenizer_config"]()
+        elif isinstance(semantic_tokenizer_config, dict):
+            semantic_tokenizer_config["model_type"] = "vibevoice_semantic_tokenizer"
+            self.semantic_tokenizer_config = self.sub_configs["semantic_tokenizer_config"](
+                **semantic_tokenizer_config
+            )
+        else:
+            self.semantic_tokenizer_config = semantic_tokenizer_config
+        
+        # ── decoder_config (NOW SUPPORTS QWEN3!) ──
+        if decoder_config is None:
+            self.decoder_config = self.sub_configs["decoder_config"]()
+        elif isinstance(decoder_config, dict):
+            model_type = decoder_config.get("model_type", "")
+            if model_type == "qwen2":
+                self.decoder_config = Qwen2Config(**decoder_config)
+            elif model_type == "qwen3":
+                self.decoder_config = Qwen3Config(**decoder_config)
+            else:
+                # Try Qwen2Config as fallback (for "vibepod" etc.)
+                try:
+                    self.decoder_config = Qwen2Config(**decoder_config)
+                except Exception:
+                    raise ValueError(
+                        f"Unsupported decoder model type: {model_type}. "
+                        f"Supported: 'qwen2', 'qwen3'"
+                    )
+        elif isinstance(decoder_config, (Qwen2Config, Qwen3Config)):
+            self.decoder_config = decoder_config
+        elif isinstance(decoder_config, PretrainedConfig):
+            # Accept any PretrainedConfig (e.g., Qwen3Config instance)
+            self.decoder_config = decoder_config
+        else:
+            raise ValueError(f"Invalid decoder_config type: {type(decoder_config)}")
+        
+        # ── diffusion_head_config ──
+        if diffusion_head_config is None:
+            self.diffusion_head_config = self.sub_configs["diffusion_head_config"]()
+        elif isinstance(diffusion_head_config, dict):
+            diffusion_head_config["model_type"] = "vibevoice_diffusion_head"
+            self.diffusion_head_config = self.sub_configs["diffusion_head_config"](
+                **diffusion_head_config
+            )
+        else:
+            self.diffusion_head_config = diffusion_head_config
+        
+        # Derived dimensions
+        self.acoustic_vae_dim = getattr(self.acoustic_tokenizer_config, "vae_dim", 64)
+        self.semantic_vae_dim = getattr(self.semantic_tokenizer_config, "vae_dim", 128)
+        
+        PretrainedConfig.__init__(self, **kwargs)
+    
+    VibeVoiceConfig.__init__ = _new_init
+    print("✅ VibeVoiceConfig patched to accept Qwen3Config")
+
+
+# Apply the patch immediately
+_patch_vibevoice_config_for_qwen3()
+
+
+# ============================================================================
+# SECTION 3: Surgery Module Definition
+# ============================================================================
+
+class Qwen3SurgeryModule(nn.Module):
+    """
+    Bridges Qwen3-4B (2560-dim) to VibeVoice Diffusion Head (3584-dim).
+
+    Pipeline:
+      1. Hierarchical Feature Extraction — extract hidden states from 4
+         intermediate Qwen3 layers (rich prosody / emotion / phonetic info)
+      2. Learnable Weighted Sum — softmax-weighted average (memory-efficient)
+      3. RMSNorm — numerical stabilisation across layer magnitudes
+      4. SwiGLU — non-linear translation between vector spaces
+      5. Linear Projection — upscale 2560 → 3584 for the Diffusion Head
+
+    Args:
+        input_dim:       Qwen3 hidden size (2560)
+        output_dim:      Diffusion Head hidden size (3584)
+        layer_indices:   0-indexed transformer layer indices to extract
+        rms_norm_eps:    Epsilon for RMSNorm
+    """
+
+    def __init__(
+        self,
+        input_dim: int = 2560,
+        output_dim: int = 3584,
+        layer_indices: Optional[List[int]] = None,
+        rms_norm_eps: float = 1e-6,
+    ):
+        super().__init__()
+        if layer_indices is None:
+            layer_indices = [24, 28, 32, 34]
+
+        self.input_dim = input_dim
+        self.output_dim = output_dim
+        self.layer_indices = layer_indices
+        self.num_layers = len(layer_indices)
+
+        # Step 2: Learnable Weighted Sum
+        self.layer_weights = nn.Parameter(torch.zeros(self.num_layers))
+
+        # Step 3: RMSNorm
+        self.norm = LlamaRMSNorm(input_dim, eps=rms_norm_eps)
+
+        # Step 4: SwiGLU
+        self.swiglu_gate = nn.Linear(input_dim, input_dim, bias=False)
+        self.swiglu_up = nn.Linear(input_dim, input_dim, bias=False)
+
+        # Step 5: Linear Projection
+        self.output_proj = nn.Linear(input_dim, output_dim, bias=False)
+
+        self._initialize_weights()
+
+    def _initialize_weights(self):
+        nn.init.normal_(self.swiglu_gate.weight, std=0.02)
+        nn.init.normal_(self.swiglu_up.weight, std=0.02)
+        # Zero-init output → safe start for fine-tuning
+        nn.init.zeros_(self.output_proj.weight)
+        nn.init.zeros_(self.layer_weights)
+
+    def forward(self, all_hidden_states: Tuple[torch.Tensor, ...]) -> torch.Tensor:
+        """
+        Args:
+            all_hidden_states: Tuple of (num_layers+1) tensors [B, Seq, input_dim].
+                Index 0 = embedding, index i+1 = transformer layer i.
+
+        Returns:
+            Transformed features [B, Seq, output_dim]
+        """
+        # Step 1: Extract selected layers
+        selected = [all_hidden_states[i + 1] for i in self.layer_indices]
+
+        # Step 2: Weighted sum
+        weights = F.softmax(self.layer_weights, dim=0)
+        merged = torch.zeros_like(selected[0])
+        for w, h in zip(weights, selected):
+            merged = merged + w * h
+
+        # Step 3: Normalise
+        merged = self.norm(merged)
+
+        # Step 4: SwiGLU
+        gate = F.silu(self.swiglu_gate(merged))
+        up = self.swiglu_up(merged)
+        hidden = gate * up
+
+        # Step 5: Project
+        return self.output_proj(hidden)
+
+    def extra_repr(self) -> str:
+        return (
+            f"input_dim={self.input_dim}, output_dim={self.output_dim}, "
+            f"layers={self.layer_indices}"
+        )
+
+
+print("✅ Surgery Module class defined")
+
+
+# ============================================================================
+# SECTION 4: Surgery Functions
+# ============================================================================
+
+def create_qwen3_config_for_surgery() -> "Qwen3Config":
+    """Create a Qwen3Config with the correct parameters for surgery."""
+    from transformers import Qwen3Config
+    
+    return Qwen3Config(
+        hidden_size=QWEN3_HIDDEN_SIZE,
+        num_hidden_layers=QWEN3_NUM_LAYERS,
+        num_attention_heads=32,
+        num_key_value_heads=8,
+        intermediate_size=9728,
+        hidden_act="silu",
+        max_position_embeddings=262144,
+        max_window_layers=36,
+        rms_norm_eps=1e-6,
+        vocab_size=QWEN3_VOCAB_SIZE,
+        tie_word_embeddings=True,
+        rope_theta=5000000,
+        head_dim=128,
+        torch_dtype="float16",
+        _attn_implementation=ATTN_IMPL,
+    )
+
+
+def perform_surgery(
+    vibevoice_model: VibeVoiceForConditionalGenerationInference,
+    qwen3_model,
+    surgery_layer_indices: Optional[List[int]] = None,
+    dtype: torch.dtype = DTYPE,
+) -> VibeVoiceForConditionalGenerationInference:
+    """
+    Perform the complete model surgery on CPU:
+      1. Replace Qwen2.5-7B language model with Qwen3-4B
+      2. Replace acoustic & semantic connectors for new hidden size
+      3. Replace lm_head for new vocab size
+      4. Add Surgery Module
+      5. Patch forward methods
+      6. Update config
+
+    Args:
+        vibevoice_model: Original VibeVoice 7B model (loaded on CPU)
+        qwen3_model:     Loaded Qwen3-4B model (loaded on CPU)
+        surgery_layer_indices: Which Qwen3 layers to extract
+        dtype:           Target dtype (float16 for T4)
+
+    Returns:
+        Modified VibeVoice model with surgery applied
+    """
+    if surgery_layer_indices is None:
+        surgery_layer_indices = SURGERY_LAYER_INDICES
+
+    print("\n" + "=" * 64)
+    print("  PERFORMING MODEL SURGERY (on CPU)")
+    print("=" * 64)
+
+    # ── Step 1: Replace Language Model ──
+    print("\n[1/6] Replacing language model: Qwen2.5-7B → Qwen3-4B...")
+    qwen3_base = qwen3_model.model  # Qwen3Model (without lm_head)
+
+    old_lm = vibevoice_model.model.language_model
+    del old_lm
+    vibevoice_model.model.language_model = qwen3_base
+    print(f"   ✓ Language model replaced ({QWEN3_HIDDEN_SIZE}-dim, {QWEN3_NUM_LAYERS} layers)")
+
+    # ── Step 2: Replace Acoustic Connector ──
+    print("\n[2/6] Replacing acoustic connector...")
+    old_acoustic = vibevoice_model.model.acoustic_connector
+    del old_acoustic
+    vibevoice_model.model.acoustic_connector = SpeechConnector(
+        input_dim=vibevoice_model.config.acoustic_vae_dim,   # 64
+        output_dim=QWEN3_HIDDEN_SIZE,                        # 2560
+    ).to(dtype=dtype)
+    print(f"   ✓ Acoustic connector: 64 → {QWEN3_HIDDEN_SIZE}")
+
+    # ── Step 3: Replace Semantic Connector ──
+    print("\n[3/6] Replacing semantic connector...")
+    old_semantic = vibevoice_model.model.semantic_connector
+    del old_semantic
+    vibevoice_model.model.semantic_connector = SpeechConnector(
+        input_dim=vibevoice_model.config.semantic_vae_dim,   # 128
+        output_dim=QWEN3_HIDDEN_SIZE,                        # 2560
+    ).to(dtype=dtype)
+    print(f"   ✓ Semantic connector: 128 → {QWEN3_HIDDEN_SIZE}")
+
+    # ── Step 4: Replace LM Head ──
+    print("\n[4/6] Replacing LM head...")
+    old_head = vibevoice_model.lm_head
+    del old_head
+    vibevoice_model.lm_head = nn.Linear(
+        QWEN3_HIDDEN_SIZE, QWEN3_VOCAB_SIZE, bias=False
+    ).to(dtype=dtype)
+
+    # Tie weights (Qwen3 uses tie_word_embeddings=True)
+    if hasattr(vibevoice_model.model.language_model, "embed_tokens"):
+        vibevoice_model.lm_head.weight = vibevoice_model.model.language_model.embed_tokens.weight
+        print("   ✓ LM head weights tied to embed_tokens")
+    print(f"   ✓ LM head: {QWEN3_HIDDEN_SIZE} → {QWEN3_VOCAB_SIZE}")
+
+    # ── Step 5: Add Surgery Module ──
+    print("\n[5/6] Adding Surgery Module...")
+    surgery_module = Qwen3SurgeryModule(
+        input_dim=QWEN3_HIDDEN_SIZE,
+        output_dim=DIFFUSION_HIDDEN_SIZE,
+        layer_indices=surgery_layer_indices,
+        rms_norm_eps=1e-6,
+    ).to(dtype=dtype)
+    vibevoice_model.model.surgery_module = surgery_module
+
+    surgery_params = sum(p.numel() for p in surgery_module.parameters())
+    print(f"   ✓ Surgery Module: {surgery_params:,} parameters")
+    print(f"   ✓ Pipeline: layers{surgery_layer_indices} → WeightedSum → "
+          f"RMSNorm → SwiGLU → Linear({QWEN3_HIDDEN_SIZE}→{DIFFUSION_HIDDEN_SIZE})")
+
+    # ── Step 6: Patch Forward Methods ──
+    print("\n[6/6] Patching forward & generate methods...")
+    _patch_base_model_forward(vibevoice_model.model)
+    _patch_inference_forward(vibevoice_model)
+    _patch_generate_method(vibevoice_model)
+
+    # ── Update Config ──
+    print("\n[Extra] Updating model config...")
+    _update_config_for_qwen3(vibevoice_model)
+
+    # ── Verify Diffusion Head untouched ──
+    print("\n[Verify] Diffusion Head (should be unchanged):")
+    dh = vibevoice_model.model.prediction_head
+    print(f"   cond_proj:          {dh.cond_proj.weight.shape}")
+    print(f"   noisy_images_proj:  {dh.noisy_images_proj.weight.shape}")
+    print(f"   hidden_size:        {dh.config.hidden_size}")
+
+    print("\n" + "=" * 64)
+    print("  SURGERY COMPLETE!")
+    print("=" * 64)
+
+    return vibevoice_model
+
+
+def _update_config_for_qwen3(model):
+    """Update the model's config to reflect Qwen3 decoder dimensions."""
+    qwen3_config = create_qwen3_config_for_surgery()
+    model.config.decoder_config = qwen3_config
+    
+    # Also set tie_word_embeddings at the top level for the inference class's tie_weights
+    model.config.tie_word_embeddings = True
+
+
+def _patch_base_model_forward(model: VibeVoiceModel):
+    """
+    Patch VibeVoiceModel.forward to always return hidden_states.
+    The Surgery Module needs access to intermediate layer hidden states.
+    """
+    original_forward = model.forward
+
+    @functools.wraps(original_forward)
+    def patched_forward(
+        self,
+        input_ids=None,
+        attention_mask=None,
+        position_ids=None,
+        past_key_values=None,
+        inputs_embeds=None,
+        use_cache=None,
+        output_attentions=None,
+        output_hidden_states=None,  # Will be forced True
+        return_dict=None,
+        cache_position=None,
+        **kwargs,
+    ):
+        return original_forward(
+            input_ids=input_ids,
+            attention_mask=attention_mask,
+            position_ids=position_ids,
+            past_key_values=past_key_values,
+            inputs_embeds=inputs_embeds,
+            use_cache=use_cache,
+            output_attentions=output_attentions,
+            output_hidden_states=True,  # Always True for Surgery Module
+            return_dict=return_dict,
+            cache_position=cache_position,
+            **kwargs,
+        )
+
+    model.forward = types.MethodType(patched_forward, model)
+    print("   ✓ Base model forward patched (output_hidden_states=True)")
+
+
+def _patch_inference_forward(model: VibeVoiceForConditionalGenerationInference):
+    """
+    Patch the inference forward to:
+      1. Force output_hidden_states=True
+      2. Include hidden_states in the return value (needed by surgery module)
+    """
+    original_forward = model.__class__.forward
+
+    def patched_forward(
+        self,
+        input_ids=None,
+        attention_mask=None,
+        position_ids=None,
+        past_key_values=None,
+        inputs_embeds=None,
+        labels=None,
+        use_cache=None,
+        output_attentions=None,
+        output_hidden_states=None,
+        return_dict=None,
+        cache_position=None,
+        speech_tensors=None,
+        speech_masks=None,
+        speech_input_mask=None,
+        logits_to_keep=0,
+        **kwargs,
+    ):
+        return_dict = return_dict if return_dict is not None else self.config.use_return_dict
+
+        # Get embeddings
+        if inputs_embeds is None:
+            inputs_embeds = self.model.get_input_embeddings()(input_ids)
+
+        # Process speech inputs
+        if speech_tensors is not None and speech_masks is not None:
+            acoustic_features, speech_embeds = self._process_speech_inputs(
+                speech_tensors.to(self.dtype), speech_masks
+            )
+            if speech_input_mask is not None:
+                inputs_embeds[speech_input_mask] = speech_embeds
+
+        # Always output hidden states for Surgery Module
+        outputs = self.model(
+            inputs_embeds=inputs_embeds,
+            attention_mask=attention_mask,
+            position_ids=position_ids,
+            past_key_values=past_key_values,
+            use_cache=use_cache,
+            output_attentions=output_attentions,
+            output_hidden_states=True,  # Always True!
+            return_dict=return_dict,
+            cache_position=cache_position,
+            **kwargs,
+        )
+
+        hidden_states = outputs[0] if not return_dict else outputs.last_hidden_state
+        slice_indices = (
+            slice(-logits_to_keep, None)
+            if isinstance(logits_to_keep, int)
+            else logits_to_keep
+        )
+        logits = self.lm_head(hidden_states[:, slice_indices, :])
+
+        if labels is not None:
+            raise NotImplementedError("Loss computation not implemented in surgery version.")
+
+        # KEY CHANGE: Include hidden_states in the output
+        return VibeVoiceCausalLMOutputWithPast(
+            logits=logits,
+            past_key_values=outputs.past_key_values,
+            last_hidden_state=hidden_states,
+            hidden_states=outputs.hidden_states,  # ← All layer hidden states
+            attentions=outputs.attentions,
+        )
+
+    model.forward = types.MethodType(patched_forward, model)
+    print("   ✓ Inference forward patched (includes hidden_states)")
+
+
+def _patch_generate_method(model: VibeVoiceForConditionalGenerationInference):
+    """
+    Patch generate to use the Surgery Module for conditioning.
+    
+    Key changes vs. original generate:
+      1. Forward calls use output_hidden_states=True
+      2. Conditioning uses Surgery Module instead of last_hidden_state
+      3. Device-aware surgery module calls for multi-GPU
+    """
+    from tqdm import tqdm
+    from transformers.generation import GenerationConfig, LogitsProcessorList, StoppingCriteriaList
+
+    def patched_generate(
+        self,
+        inputs=None,
+        generation_config=None,
+        logits_processor=None,
+        stopping_criteria=None,
+        prefix_allowed_tokens_fn=None,
+        synced_gpus=None,
+        assistant_model=None,
+        audio_streamer=None,
+        negative_prompt_ids=None,
+        negative_prompt_attention_mask=None,
+        speech_tensors=None,
+        speech_masks=None,
+        speech_input_mask=None,
+        return_speech=True,
+        cfg_scale=1.0,
+        stop_check_fn=None,
+        **kwargs,
+    ):
+        """Modified generate that uses Surgery Module for conditioning."""
+        # ── Setup ──
+        tokenizer = kwargs.pop("tokenizer", None)
+        parsed_scripts = kwargs.pop("parsed_scripts", None)
+        all_speakers_list = kwargs.pop("all_speakers_list", None)
+        max_length_times = kwargs.pop("max_length_times", 2)
+
+        if kwargs.get("max_new_tokens", None) is None:
+            kwargs["max_new_tokens"] = (
+                self.config.decoder_config.max_position_embeddings
+                - kwargs["input_ids"].shape[-1]
+            )
+
+        (
+            generation_config, model_kwargs, input_ids,
+            logits_processor, stopping_criteria,
+        ) = self._build_generate_config_model_kwargs(
+            generation_config, inputs, tokenizer,
+            return_processors=True, **kwargs,
+        )
+
+        negative_kwargs = {
+            "input_ids": torch.full(
+                (kwargs["input_ids"].shape[0], 1),
+                tokenizer.speech_start_id,
+                dtype=torch.long, device=kwargs["input_ids"].device,
+            ),
+            "attention_mask": torch.ones(
+                (kwargs["input_ids"].shape[0], 1),
+                dtype=torch.long, device=kwargs["input_ids"].device,
+            ),
+            "max_new_tokens": kwargs.get("max_new_tokens", 100),
+        }
+        negative_generation_config, negative_model_kwargs, negative_input_ids = (
+            self._build_generate_config_model_kwargs(
+                None, None, tokenizer,
+                return_processors=False, **negative_kwargs,
+            )
+        )
+
+        acoustic_cache = VibeVoiceTokenizerStreamingCache()
+        semantic_cache = VibeVoiceTokenizerStreamingCache()
+
+        batch_size = input_ids.shape[0]
+        device = input_ids.device
+        finished_tags = torch.zeros(batch_size, dtype=torch.bool, device=device)
+        correct_cnt = torch.zeros(batch_size, dtype=torch.long, device=device)
+        is_prefill = True
+        inputs_embeds = None
+        verbose = kwargs.get("verbose", False)
+
+        audio_chunks = [[] for _ in range(batch_size)]
+
+        initial_length = input_ids.shape[-1]
+        initial_length_per_sample = model_kwargs["attention_mask"].sum(dim=-1)
+
+        valid_tokens = [
+            generation_config.speech_start_id,
+            generation_config.speech_end_id,
+            generation_config.speech_diffusion_id,
+            generation_config.eos_token_id,
+        ]
+        if hasattr(generation_config, "bos_token_id") and generation_config.bos_token_id is not None:
+            valid_tokens.append(generation_config.bos_token_id)
+
+        token_constraint_processor = VibeVoiceTokenConstraintProcessor(valid_tokens, device=device)
+        if logits_processor is None:
+            logits_processor = LogitsProcessorList()
+        logits_processor.append(token_constraint_processor)
+
+        max_steps = min(
+            generation_config.max_length - initial_length,
+            int(max_length_times * initial_length),
+        )
+        max_step_per_sample = torch.minimum(
+            generation_config.max_length - initial_length_per_sample,
+            (max_length_times * initial_length_per_sample).long(),
+        )
+        reach_max_step_sample = torch.zeros(batch_size, dtype=torch.bool, device=device)
+
+        progress_bar = (
+            tqdm(range(max_steps), desc="Generating", leave=False)
+            if kwargs.get("show_progress_bar", True)
+            else range(max_steps)
+        )
+
+        # Device resolution for multi-GPU compatibility
+        # acoustic_tokenizer and semantic_tokenizer may live on different GPUs
+        acoustic_device = next(self.model.acoustic_tokenizer.parameters()).device
+        semantic_device = next(self.model.semantic_tokenizer.parameters()).device
+        acoustic_connect_device = next(self.model.acoustic_connector.parameters()).device
+        semantic_connect_device = next(self.model.semantic_connector.parameters()).device
+
+        # Helper: run surgery module with correct device placement
+        # Optimization: only pass last token since we only need surgery_out[:, -1, :]
+        def _run_surgery(hidden_states_tuple):
+            """Run surgery module on last token only, handling multi-GPU placement."""
+            surgery_mod = self.model.surgery_module
+            surgery_device = next(surgery_mod.parameters()).device
+            # Slice to last token only — avoids O(N²) on full sequence
+            # Each hidden_state is [B, Seq, D], we take [:, -1:, :] → [B, 1, D]
+            selected = tuple(h[:, -1:, :] for h in hidden_states_tuple)
+            if selected[0].device != surgery_device:
+                selected = tuple(h.to(surgery_device) for h in selected)
+            return surgery_mod(selected)
+
+        # ── Generation Loop ──
+        for step in progress_bar:
+            if stop_check_fn is not None and stop_check_fn():
+                if verbose:
+                    print(f"Generation stopped externally at step {step + 1}")
+                if audio_streamer is not None:
+                    audio_streamer.end()
+                break
+
+            if audio_streamer is not None and hasattr(audio_streamer, "finished_flags"):
+                if any(audio_streamer.finished_flags):
+                    if verbose:
+                        print(f"Audio generation stopped externally at step {step + 1}")
+                    break
+
+            if finished_tags.all():
+                if hasattr(progress_bar, "set_description"):
+                    progress_bar.set_description("Generation complete")
+                break
+
+            if input_ids.shape[-1] >= generation_config.max_length:
+                print(f"Reached max generation length {generation_config.max_length}")
+                reached = torch.arange(batch_size, device=device)[~finished_tags]
+                if reached.numel() > 0:
+                    reach_max_step_sample[reached] = True
+                break
+
+            if hasattr(progress_bar, "set_description"):
+                active = (~finished_tags).sum().item()
+                progress_bar.set_description(f"Generating (active: {active}/{batch_size})")
+
+            model_inputs = self.prepare_inputs_for_generation(input_ids, **model_kwargs)
+            if is_prefill:
+                prefill_inputs = {
+                    "speech_tensors": speech_tensors.to(device=device),
+                    "speech_masks": speech_masks.to(device),
+                    "speech_input_mask": speech_input_mask.to(device),
+                }
+                is_prefill = False
+            else:
+                _ = model_inputs.pop("inputs_embeds", None)
+                prefill_inputs = {"inputs_embeds": inputs_embeds}
+
+            # Forward (output_hidden_states=True is handled by patched forward)
+            outputs = self(
+                **model_inputs, **prefill_inputs,
+                logits_to_keep=1, return_dict=True,
+                output_attentions=False, output_hidden_states=True,
+            )
+            model_kwargs = self._update_model_kwargs_for_generation(
+                outputs, model_kwargs, is_encoder_decoder=False,
+            )
+
+            next_token_logits = outputs.logits[:, -1, :].to(
+                copy=True, dtype=torch.float32, device=input_ids.device,
+            )
+            next_token_scores = logits_processor(input_ids, next_token_logits)
+
+            if generation_config.do_sample:
+                probs = nn.functional.softmax(next_token_scores, dim=-1)
+                next_tokens = torch.multinomial(probs, num_samples=1).squeeze(1)
+            else:
+                next_tokens = torch.argmax(next_token_scores, dim=-1)
+
+            next_tokens[finished_tags] = generation_config.eos_token_id
+            input_ids = torch.cat([input_ids, next_tokens[:, None]], dim=-1)
+
+            # Negative prompt update (non-refresh mode)
+            if not kwargs.get("refresh_negative", True):
+                negative_model_inputs = self.prepare_inputs_for_generation(
+                    negative_input_ids, **negative_model_kwargs
+                )
+                if negative_model_inputs["inputs_embeds"] is None and inputs_embeds is not None:
+                    negative_model_inputs["inputs_embeds"] = inputs_embeds
+                    negative_model_inputs["input_ids"] = None
+
+                negative_outputs = self(
+                    **negative_model_inputs,
+                    logits_to_keep=0, return_dict=True,
+                    output_attentions=False, output_hidden_states=True,
+                )
+                negative_model_kwargs = self._update_model_kwargs_for_generation(
+                    negative_outputs, negative_model_kwargs, is_encoder_decoder=False,
+                )
+                negative_input_ids = torch.cat(
+                    [negative_input_ids, next_tokens[:, None]], dim=-1
+                )
+
+            # EOS handling
+            if (next_tokens == generation_config.eos_token_id).any():
+                eos_indices = (
+                    (next_tokens == generation_config.eos_token_id)
+                    .nonzero(as_tuple=False).squeeze(1)
+                )
+                new_eos = eos_indices[~finished_tags[eos_indices]]
+                if new_eos.numel() > 0:
+                    finished_tags[new_eos] = True
+                    if verbose:
+                        print(f"Samples {new_eos.tolist()} reached EOS at step {step+1}.", flush=True)
+                    if audio_streamer is not None:
+                        audio_streamer.end(new_eos)
+
+            # Max length handling
+            max_reached = step >= max_step_per_sample
+            new_max = torch.nonzero(max_reached & ~finished_tags, as_tuple=False).squeeze(1)
+            if new_max.numel() > 0:
+                finished_tags[new_max] = True
+                reach_max_step_sample[new_max] = True
+                if verbose:
+                    print(f"Samples {new_max.tolist()} reached max length at step {step+1}.", flush=True)
+                if audio_streamer is not None:
+                    audio_streamer.end(new_max)
+
+            # speech_end
+            diffusion_end = (
+                (next_tokens == generation_config.speech_end_id)
+                .nonzero(as_tuple=False).squeeze(1)
+            )
+            if diffusion_end.numel() > 0:
+                acoustic_cache.set_to_zero(diffusion_end)
+                semantic_cache.set_to_zero(diffusion_end)
+
+            # speech_begin — update negative prompt cache
+            diffusion_start = torch.arange(batch_size, device=device)[
+                ~finished_tags & (next_tokens == generation_config.speech_start_id)
+            ]
+            if diffusion_start.numel() > 0 and kwargs.get("refresh_negative", True):
+                for idx in diffusion_start.tolist():
+                    negative_model_kwargs["attention_mask"][idx, :] = 0
+                    negative_model_kwargs["attention_mask"][idx, -1] = 1
+                for k_cache, v_cache in zip(
+                    negative_model_kwargs["past_key_values"].key_cache,
+                    negative_model_kwargs["past_key_values"].value_cache,
+                ):
+                    for idx in diffusion_start.tolist():
+                        k_cache[idx, :, -1, :] = k_cache[idx, :, 0, :].clone()
+                        v_cache[idx, :, -1, :] = v_cache[idx, :, 0, :].clone()
+                for idx in diffusion_start.tolist():
+                    negative_input_ids[idx, -1] = generation_config.speech_start_id
+
+            # Prepare next embeddings
+            next_inputs_embeds = self.model.get_input_embeddings()(next_tokens).unsqueeze(1)
+
+            # ── Diffusion forward ──
+            diffusion_indices = torch.arange(batch_size, device=device)[
+                ~finished_tags & (next_tokens == generation_config.speech_diffusion_id)
+            ]
+
+            if diffusion_indices.numel() > 0:
+                # Negative pass for diffusion
+                if kwargs.get("refresh_negative", True):
+                    negative_model_inputs = self.prepare_inputs_for_generation(
+                        negative_input_ids, **negative_model_kwargs
+                    )
+                    if negative_model_inputs["inputs_embeds"] is None and inputs_embeds is not None:
+                        negative_model_inputs["inputs_embeds"] = inputs_embeds
+                        negative_model_inputs["input_ids"] = None
+
+                    negative_outputs = self(
+                        **negative_model_inputs,
+                        logits_to_keep=0, return_dict=True,
+                        output_attentions=False, output_hidden_states=True,
+                    )
+                    negative_model_kwargs = self._update_model_kwargs_for_generation(
+                        negative_outputs, negative_model_kwargs, is_encoder_decoder=False,
+                    )
+                    negative_input_ids = torch.cat(
+                        [negative_input_ids, next_tokens[:, None]], dim=-1
+                    )
+
+                # Correct non-diffusion samples' KV cache
+                non_diff_mask = ~finished_tags & (next_tokens != generation_config.speech_diffusion_id)
+                if non_diff_mask.any():
+                    non_diff_idx = torch.arange(batch_size, device=device)[non_diff_mask]
+                    starts = correct_cnt[non_diff_idx]
+
+                    seq_len = negative_model_kwargs["attention_mask"].shape[1]
+                    for i, (s_idx, s_start) in enumerate(
+                        zip(non_diff_idx.tolist(), starts.tolist())
+                    ):
+                        if s_start + 1 < seq_len - 1:
+                            negative_model_kwargs["attention_mask"][s_idx, s_start+1:] = \
+                                negative_model_kwargs["attention_mask"][s_idx, s_start:-1].clone()
+                        negative_model_kwargs["attention_mask"][s_idx, s_start] = 0
+
+                    for k_cache, v_cache in zip(
+                        negative_model_kwargs["past_key_values"].key_cache,
+                        negative_model_kwargs["past_key_values"].value_cache,
+                    ):
+                        for s_idx, s_start in zip(non_diff_idx.tolist(), starts.tolist()):
+                            if s_start + 1 < k_cache.shape[2] - 1:
+                                k_cache[s_idx, :, s_start+1:, :] = \
+                                    k_cache[s_idx, :, s_start:-1, :].clone()
+                                v_cache[s_idx, :, s_start+1:, :] = \
+                                    v_cache[s_idx, :, s_start:-1, :].clone()
+
+                    for s_idx, s_start in zip(non_diff_idx.tolist(), starts.tolist()):
+                        if s_start + 1 < negative_input_ids.shape[1] - 1:
+                            negative_input_ids[s_idx, s_start+1:] = \
+                                negative_input_ids[s_idx, s_start:-1].clone()
+
+                    correct_cnt[non_diff_idx] += 1
+
+                # ── SURGERY: Use Surgery Module for conditioning ──
+                # Original code used: outputs.last_hidden_state[:, -1, :]
+                # Now we transform ALL hidden states through the Surgery Module
+                surgery_out = _run_surgery(outputs.hidden_states)       # [B, Seq, 3584]
+                positive_condition = surgery_out[:, -1, :][diffusion_indices]
+
+                neg_surgery_out = _run_surgery(negative_outputs.hidden_states)
+                negative_condition = neg_surgery_out[:, -1, :][diffusion_indices]
+
+                speech_latent = self.sample_speech_tokens(
+                    positive_condition,
+                    negative_condition,
+                    cfg_scale=cfg_scale,
+                ).unsqueeze(1)
+
+                # Decode acoustic latent to audio
+                scaled_latent = (
+                    speech_latent
+                    / self.model.speech_scaling_factor.to(speech_latent.device)
+                    - self.model.speech_bias_factor.to(speech_latent.device)
+                )
+                audio_chunk = self.model.acoustic_tokenizer.decode(
+                    scaled_latent.to(self.model.acoustic_tokenizer.device),
+                    cache=acoustic_cache,
+                    sample_indices=diffusion_indices.to(self.model.acoustic_tokenizer.device),
+                    use_cache=True,
+                    debug=False,
+                )
+
+                for i, s_idx in enumerate(diffusion_indices):
+                    idx = s_idx.item()
+                    if not finished_tags[idx]:
+                        audio_chunks[idx].append(audio_chunk[i])
+
+                if audio_streamer is not None:
+                    audio_streamer.put(audio_chunk, diffusion_indices)
+
+                semantic_features = self.model.semantic_tokenizer.encode(
+                    audio_chunk,
+                    cache=semantic_cache,
+                    sample_indices=diffusion_indices,
+                    use_cache=True,
+                    debug=False,
+                ).mean
+
+                acoustic_embed = self.model.acoustic_connector(
+                    speech_latent.to(acoustic_connect_device)
+                ).to(device)
+                semantic_embed = self.model.semantic_connector(
+                    semantic_features.to(semantic_connect_device)
+                ).to(device)
+                diffusion_embeds = acoustic_embed + semantic_embed
+
+                next_inputs_embeds[diffusion_indices] = diffusion_embeds
+
+            inputs_embeds = next_inputs_embeds
+
+        if audio_streamer is not None:
+            audio_streamer.end()
+
+        # Concatenate audio chunks
+        final_audio_outputs = []
+        for sample_chunks in audio_chunks:
+            if sample_chunks:
+                final_audio_outputs.append(torch.cat(sample_chunks, dim=-1))
+            else:
+                final_audio_outputs.append(None)
+
+        return VibeVoiceGenerationOutput(
+            sequences=input_ids,
+            speech_outputs=final_audio_outputs if return_speech else None,
+            reach_max_step_sample=reach_max_step_sample,
+        )
+
+    model.generate = types.MethodType(patched_generate, model)
+    print("   ✓ Generate method patched (Surgery Module integrated)")
+
+
+# ============================================================================
+# SECTION 5: Custom Model Class for Save/Load
+# ============================================================================
+
+class VibeVoiceSurgeryModel(VibeVoiceForConditionalGenerationInference):
+    """
+    Extended VibeVoice inference model that includes the Surgery Module
+    in its __init__, so from_pretrained can load surgery weights correctly.
+    """
+    
+    def __init__(self, config):
+        super().__init__(config)
+        # Add surgery module if config includes it
+        if hasattr(config, "surgery_module_config"):
+            sc = config.surgery_module_config
+            self.model.surgery_module = Qwen3SurgeryModule(
+                input_dim=sc.get("input_dim", QWEN3_HIDDEN_SIZE),
+                output_dim=sc.get("output_dim", DIFFUSION_HIDDEN_SIZE),
+                layer_indices=sc.get("layer_indices", SURGERY_LAYER_INDICES),
+                rms_norm_eps=sc.get("rms_norm_eps", 1e-6),
+            )
+
+
+# Register with AutoModel so from_pretrained works
+AutoModelForCausalLM.register(VibeVoiceConfig, VibeVoiceSurgeryModel)
+
+
+# ============================================================================
+# SECTION 6: Memory Estimation
+# ============================================================================
+
+def estimate_memory():
+    """Print memory estimates for the surgery process."""
+    bytes_per_param = 2  # float16
+    
+    qwen3_gb = QWEN3_NUM_LAYERS * 0.22  # rough estimate ~8GB
+    vibevoice_total_gb = 14.0  # ~7B params in fp16
+    vibevoice_excl_lm_gb = 3.0  # diffusion head + tokenizers + connectors
+    surgery_gb = 0.05  # ~25M params
+    
+    final_model_gb = qwen3_gb + vibevoice_excl_lm_gb + surgery_gb
+    during_surgery_gb = vibevoice_total_gb + qwen3_gb
+    
+    print(f"\n📊 Memory Estimates (float16):")
+    print(f"   VibeVoice 7B (CPU RAM):     ~{vibevoice_total_gb:.1f} GB")
+    print(f"   Qwen3-4B (CPU RAM):         ~{qwen3_gb:.1f} GB")
+    print(f"   During surgery (CPU RAM):   ~{during_surgery_gb:.1f} GB")
+    print(f"   Final model (VRAM):         ~{final_model_gb:.1f} GB")
+    print(f"   Kaggle CPU RAM available:   ~30 GB")
+    print(f"   Kaggle GPU VRAM (2×T4):     32 GB total")
+    print(f"   ✅ Fits comfortably!")
+
+
+# ============================================================================
+# SECTION 7: Main Surgery Pipeline
+# ============================================================================
+
+def run_surgery():
+    """
+    Execute the complete surgery pipeline:
+      1. Load VibeVoice 7B on CPU
+      2. Load Qwen3-4B on CPU
+      3. Perform surgery on CPU
+      4. Save modified model
+      5. Reload with device_map across 2 T4 GPUs
+    """
+    print("\n" + "█" * 64)
+    print("  VIBEVOICE MODEL SURGERY")
+    print("  Qwen2.5-7B → Qwen3-4B + Surgery Module")
+    print("  Target: Kaggle Dual T4 GPUs")
+    print("█" * 64)
+
+    estimate_memory()
+
+    # ── Step 1: Load VibeVoice 7B on CPU ──
+    print("\n[Step 1/5] Loading VibeVoice 7B on CPU...")
+    gc.collect()
+    torch.cuda.empty_cache()
+
+    try:
+        vibevoice_model = VibeVoiceForConditionalGenerationInference.from_pretrained(
+            VIBEVOICE_MODEL_ID,
+            torch_dtype=DTYPE,
+            device_map="cpu",
+            trust_remote_code=True,
+        )
+        print(f"  ✓ VibeVoice 7B loaded on CPU")
+    except Exception as e:
+        print(f"  ✗ Failed: {e}")
+        raise
+
+    print(f"  Original decoder: {vibevoice_model.config.decoder_config.hidden_size}-dim, "
+          f"{vibevoice_model.config.decoder_config.num_hidden_layers} layers, "
+          f"vocab={vibevoice_model.config.decoder_config.vocab_size}")
+
+    # ── Step 2: Load Qwen3-4B on CPU ──
+    print(f"\n[Step 2/5] Loading {QWEN3_MODEL_ID} on CPU...")
+    gc.collect()
+    torch.cuda.empty_cache()
+
+    try:
+        qwen3_model = AutoModelForCausalLM.from_pretrained(
+            QWEN3_MODEL_ID,
+            torch_dtype=DTYPE,
+            device_map="cpu",
+            trust_remote_code=True,
+        )
+        print(f"  ✓ Qwen3-4B loaded on CPU")
+    except Exception as e:
+        print(f"  ✗ Failed: {e}")
+        print(f"  ℹ  Ensure transformers>=4.51.0: pip install 'transformers>=4.51.0'")
+        raise
+
+    # Verify dimensions
+    assert qwen3_model.config.hidden_size == QWEN3_HIDDEN_SIZE
+    assert qwen3_model.config.num_hidden_layers == QWEN3_NUM_LAYERS
+    assert qwen3_model.config.vocab_size == QWEN3_VOCAB_SIZE
+    print(f"  Qwen3: {QWEN3_HIDDEN_SIZE}-dim, {QWEN3_NUM_LAYERS} layers, vocab={QWEN3_VOCAB_SIZE}")
+
+    # ── Step 3: Perform Surgery on CPU ──
+    print(f"\n[Step 3/5] Performing surgery on CPU...")
+    modified_model = perform_surgery(
+        vibevoice_model=vibevoice_model,
+        qwen3_model=qwen3_model,
+        surgery_layer_indices=SURGERY_LAYER_INDICES,
+        dtype=DTYPE,
+    )
+
+    # Free Qwen3 model (its weights are now in the modified model)
+    del qwen3_model
+    gc.collect()
+    torch.cuda.empty_cache()
+
+    # ── Step 4: Save Surgery Model ──
+    print(f"\n[Step 4/5] Saving surgery model to {OUTPUT_DIR}...")
+    save_surgery_model(modified_model, OUTPUT_DIR)
+
+    # Free CPU model
+    del modified_model
+    gc.collect()
+    torch.cuda.empty_cache()
+
+    # ── Step 5: Reload with device_map across 2 T4s ──
+    print(f"\n[Step 5/5] Loading with device_map across 2 T4 GPUs...")
+    final_model = load_surgery_model(
+        OUTPUT_DIR,
+        dtype=DTYPE,
+        device_map="auto",
+    )
+
+    # Print summary
+    print_surgery_summary(final_model)
+
+    return final_model
+
+
+# ============================================================================
+# SECTION 8: Save & Load Functions
+# ============================================================================
+
+def save_surgery_model(model, output_dir: str):
+    """
+    Save the surgery model in a format that can be reloaded correctly.
+    
+    Key: We save decoder_config with model_type="qwen2" but Qwen3 parameters.
+    This avoids the VibeVoiceConfig validation issue on reload.
+    The monkey-patch we applied handles qwen3, but for saved configs we use
+    a compatible format.
+    """
+    os.makedirs(output_dir, exist_ok=True)
+    print(f"  Saving model weights...")
+    model.save_pretrained(output_dir, safe_serialization=True)
+    print(f"  ✓ Model weights saved")
+
+    # Save config with surgery_module_config
+    print(f"  Saving config...")
+    config_dict = model.config.to_dict()
+    
+    # Save decoder config as qwen3 (our patched VibeVoiceConfig handles it)
+    qwen3_cfg = create_qwen3_config_for_surgery()
+    config_dict["decoder_config"] = qwen3_cfg.to_dict()
+    config_dict["decoder_config"]["model_type"] = "qwen3"
+
+    # Add surgery module config
+    config_dict["surgery_module_config"] = {
+        "input_dim": QWEN3_HIDDEN_SIZE,
+        "output_dim": DIFFUSION_HIDDEN_SIZE,
+        "layer_indices": SURGERY_LAYER_INDICES,
+        "rms_norm_eps": 1e-6,
+    }
+
+    config_path = os.path.join(output_dir, "config.json")
+    with open(config_path, "w") as f:
+        json.dump(config_dict, f, indent=2, default=str)
+    print(f"  ✓ Config saved")
+
+    # Save surgery config separately
+    surgery_config_path = os.path.join(output_dir, "surgery_module_config.json")
+    with open(surgery_config_path, "w") as f:
+        json.dump(config_dict["surgery_module_config"], f, indent=2)
+    print(f"  ✓ Surgery module config saved")
+
+    # Print file sizes
+    print(f"\n  Saved files:")
+    total_size = 0
+    for f_name in sorted(os.listdir(output_dir)):
+        f_path = os.path.join(output_dir, f_name)
+        if os.path.isfile(f_path):
+            size_mb = os.path.getsize(f_path) / 1e6
+            total_size += size_mb
+            print(f"    {f_name}: {size_mb:.1f} MB")
+    print(f"  Total: {total_size:.1f} MB ({total_size/1024:.2f} GB)")
+    print(f"  ✓ Saved to {output_dir}")
+
+
+def load_surgery_model(
+    model_path: str,
+    dtype: torch.dtype = DTYPE,
+    device_map: str = "auto",
+):
+    """
+    Load a previously saved surgery model.
+    
+    Uses VibeVoiceSurgeryModel (custom class) so that from_pretrained
+    creates the surgery_module before loading weights.
+    
+    Also applies the runtime forward/generate patches.
+    
+    Fix: When device_map="auto", the auto-generated device map misses
+    registered buffers (speech_scaling_factor, speech_bias_factor) that
+    live directly on VibeVoiceModel. We manually add those entries.
+    """
+    print(f"\n  Loading surgery model from {model_path}...")
+    
+    # Ensure config patch is applied (in case this is called standalone)
+    _patch_vibevoice_config_for_qwen3()
+
+    # Load config to get surgery_module_config
+    config_path = os.path.join(model_path, "config.json")
+    with open(config_path, "r") as f:
+        config_dict = json.load(f)
+
+    # Create config using our patched VibeVoiceConfig
+    config = VibeVoiceConfig(**config_dict)
+
+    # ── Fix device_map for registered buffers ──
+    if device_map == "auto":
+        from accelerate import infer_auto_device_map, get_max_memory
+
+        print("  Computing device map for multi-GPU placement...")
+        max_memory = get_max_memory()
+
+        # Build a meta-device model to infer the device map structure
+        with torch.device("meta"):
+            meta_model = VibeVoiceSurgeryModel(config)
+
+        no_split = [
+            "VibeVoiceDiffusionHead",
+            "VibeVoiceAcousticTokenizerModel",
+            "VibeVoiceSemanticTokenizerModel",
+            "Qwen3SurgeryModule",
+        ]
+
+        device_map_dict = infer_auto_device_map(
+            meta_model,
+            max_memory=max_memory,
+            no_split_module_classes=no_split,
+        )
+
+        # Determine which device to place the buffers on
+        buffer_device = device_map_dict.get(
+            "model.language_model",
+            device_map_dict.get("model", "cuda:0"),
+        )
+
+        # Add entries for registered buffers that are direct children of model
+        for key in ["model.speech_scaling_factor", "model.speech_bias_factor"]:
+            if key not in device_map_dict:
+                device_map_dict[key] = buffer_device
+                print(f"    Added device map entry: {key} → {buffer_device}")
+
+        del meta_model
+        gc.collect()
+        torch.cuda.empty_cache()
+
+        device_map = device_map_dict
+
+    # Load using our custom class that includes surgery_module in __init__
+    model = VibeVoiceSurgeryModel.from_pretrained(
+        model_path,
+        config=config,
+        torch_dtype=dtype,
+        device_map=device_map,
+        trust_remote_code=True,
+    )
+
+    # Verify surgery module
+    if not hasattr(model.model, "surgery_module"):
+        print("  ⚠  Surgery Module not found after loading, adding manually...")
+        sc = config.surgery_module_config
+        model.model.surgery_module = Qwen3SurgeryModule(**sc).to(dtype=dtype)
+        # Try to load surgery weights from the saved state dict
+        surgery_state = {
+            k.replace("model.surgery_module.", ""): v
+            for k, v in torch.load(
+                os.path.join(model_path, "model.safetensors")
+                if os.path.exists(os.path.join(model_path, "model.safetensors"))
+                else os.path.join(model_path, "pytorch_model.bin"),
+                map_location="cpu",
+            ).items()
+            if k.startswith("model.surgery_module.")
+        }
+        if surgery_state:
+            model.model.surgery_module.load_state_dict(surgery_state, strict=False)
+            print("  ✓ Surgery Module weights loaded")
+
+    # Apply runtime patches (not saved with the model)
+    _patch_base_model_forward(model.model)
+    _patch_inference_forward(model)
+    _patch_generate_method(model)
+
+    # Tie weights
+    try:
+        model.tie_weights()
+    except Exception:
+        pass
+
+    print(f"  ✓ Surgery model loaded successfully")
+    return model
+
+
+# ============================================================================
+# SECTION 9: Verification
+# ============================================================================
+
+def verify_surgery(model):
+    """Run verification tests on the modified model."""
+    print("\n" + "─" * 64)
+    print("  VERIFICATION TESTS")
+    print("─" * 64)
+
+    all_passed = True
+
+    # Test 1: Surgery Module exists
+    print("\n[Test 1] Surgery Module exists...")
+    try:
+        assert hasattr(model.model, "surgery_module")
+        sm = model.model.surgery_module
+        assert sm.input_dim == QWEN3_HIDDEN_SIZE
+        assert sm.output_dim == DIFFUSION_HIDDEN_SIZE
+        assert sm.layer_indices == SURGERY_LAYER_INDICES
+        print("  ✓ PASSED")
+    except Exception as e:
+        print(f"  ✗ FAILED: {e}")
+        all_passed = False
+
+    # Test 2: Language model is Qwen3
+    print("\n[Test 2] Language model is Qwen3...")
+    try:
+        lm = model.model.language_model
+        assert lm.config.hidden_size == QWEN3_HIDDEN_SIZE
+        assert lm.config.num_hidden_layers == QWEN3_NUM_LAYERS
+        print(f"  ✓ PASSED (hidden={QWEN3_HIDDEN_SIZE}, layers={QWEN3_NUM_LAYERS})")
+    except Exception as e:
+        print(f"  ✗ FAILED: {e}")
+        all_passed = False
+
+    # Test 3: Connectors
+    print("\n[Test 3] Connector dimensions...")
+    try:
+        ac = model.model.acoustic_connector
+        sc = model.model.semantic_connector
+        assert ac.fc1.out_features == QWEN3_HIDDEN_SIZE
+        assert sc.fc1.out_features == QWEN3_HIDDEN_SIZE
+        print("  ✓ PASSED")
+    except Exception as e:
+        print(f"  ✗ FAILED: {e}")
+        all_passed = False
+
+    # Test 4: LM Head
+    print("\n[Test 4] LM Head dimensions...")
+    try:
+        assert model.lm_head.in_features == QWEN3_HIDDEN_SIZE
+        assert model.lm_head.out_features == QWEN3_VOCAB_SIZE
+        print("  ✓ PASSED")
+    except Exception as e:
+        print(f"  ✗ FAILED: {e}")
+        all_passed = False
+
+    # Test 5: Diffusion Head unchanged
+    print("\n[Test 5] Diffusion Head (should be 3584)...")
+    try:
+        dh = model.model.prediction_head
+        assert dh.config.hidden_size == DIFFUSION_HIDDEN_SIZE
+        assert dh.cond_proj.weight.shape[0] == DIFFUSION_HIDDEN_SIZE
+        assert dh.cond_proj.weight.shape[1] == DIFFUSION_HIDDEN_SIZE
+        print("  ✓ PASSED")
+    except Exception as e:
+        print(f"  ✗ FAILED: {e}")
+        all_passed = False
+
+    # Test 6: Surgery Module forward pass
+    print("\n[Test 6] Surgery Module forward pass...")
+    try:
+        sm = model.model.surgery_module
+        device = next(sm.parameters()).device
+        dtype = next(sm.parameters()).dtype
+        with torch.no_grad():
+            dummy_hs = tuple(
+                torch.randn(1, 10, QWEN3_HIDDEN_SIZE, dtype=dtype, device=device)
+                for _ in range(QWEN3_NUM_LAYERS + 1)
+            )
+            output = sm(dummy_hs)
+            assert output.shape == (1, 10, DIFFUSION_HIDDEN_SIZE)
+            assert not torch.isnan(output).any()
+            assert not torch.isinf(output).any()
+        print(f"  ✓ PASSED [1, 10, {QWEN3_HIDDEN_SIZE}] → [1, 10, {DIFFUSION_HIDDEN_SIZE}]")
+    except Exception as e:
+        print(f"  ✗ FAILED: {e}")
+        all_passed = False
+
+    # Test 7: Layer weights uniform
+    print("\n[Test 7] Initial layer weights (uniform)...")
+    try:
+        weights = F.softmax(sm.layer_weights, dim=0)
+        expected = torch.full_like(weights, 1.0 / sm.num_layers)
+        assert torch.allclose(weights, expected, atol=1e-6)
+        print(f"  ✓ PASSED ({weights.tolist()})")
+    except Exception as e:
+        print(f"  ✗ FAILED: {e}")
+        all_passed = False
+
+    # Test 8: Output projection zero-init
+    print("\n[Test 8] Output projection zero-init...")
+    try:
+        assert torch.all(sm.output_proj.weight == 0)
+        print("  ✓ PASSED")
+    except Exception as e:
+        print(f"  ✗ FAILED: {e}")
+        all_passed = False
+
+    print("\n" + "─" * 64)
+    if all_passed:
+        print("  ✅ ALL TESTS PASSED!")
+    else:
+        print("  ⚠️  SOME TESTS FAILED — check above")
+    print("─" * 64)
+
+    return all_passed
+
+
+def print_surgery_summary(model):
+    """Print a comprehensive summary of the surgery model."""
+    print("\n" + "═" * 64)
+    print("  SURGERY SUMMARY")
+    print("═" * 64)
+
+    lm = model.model.language_model
+    lm_params = sum(p.numel() for p in lm.parameters())
+    print(f"\n┌─ Language Model (Qwen3-4B)")
+    print(f"│  Type:       {lm.__class__.__name__}")
+    print(f"│  Parameters: {lm_params:,}")
+    print(f"│  Hidden:     {model.config.decoder_config.hidden_size}")
+    print(f"│  Layers:     {model.config.decoder_config.num_hidden_layers}")
+
+    sm = model.model.surgery_module
+    sm_params = sum(p.numel() for p in sm.parameters())
+    print(f"├─ Surgery Module")
+    print(f"│  Parameters: {sm_params:,}")
+    print(f"│  {sm.extra_repr()}")
+
+    ac_params = sum(p.numel() for p in model.model.acoustic_connector.parameters())
+    sc_params = sum(p.numel() for p in model.model.semantic_connector.parameters())
+    print(f"├─ Acoustic Connector: {ac_params:,} params")
+    print(f"├─ Semantic Connector: {sc_params:,} params")
+
+    lmh_params = sum(p.numel() for p in model.lm_head.parameters())
+    print(f"├─ LM Head: {lmh_params:,} params")
+
+    dh = model.model.prediction_head
+    dh_params = sum(p.numel() for p in dh.parameters())
+    print(f"├─ Diffusion Head (unchanged): {dh_params:,} params")
+
+    at_params = sum(p.numel() for p in model.model.acoustic_tokenizer.parameters())
+    st_params = sum(p.numel() for p in model.model.semantic_tokenizer.parameters())
+    print(f"├─ Acoustic Tokenizer (unchanged): {at_params:,} params")
+    print(f"└─ Semantic Tokenizer (unchanged): {st_params:,} params")
+
+    total_params = sum(p.numel() for p in model.parameters())
+    print(f"\n  Total: {total_params:,} params (~{total_params * 2 / 1e9:.2f} GB in fp16)")
+
+    print(f"\n  Data Flow:")
+    print(f"  Audio → AcousticTokenizer → (64-dim) → AcousticConnector → ({QWEN3_HIDDEN_SIZE}-dim)")
+    print(f"  Audio → SemanticTokenizer → (128-dim) → SemanticConnector → ({QWEN3_HIDDEN_SIZE}-dim)")
+    print(f"  Combined → Qwen3-4B → hidden_states[37 × {QWEN3_HIDDEN_SIZE}-dim]")
+    print(f"  → SurgeryModule → ({DIFFUSION_HIDDEN_SIZE}-dim) → DiffusionHead → Speech")
+    print(f"  → LMHead → Text Tokens")
+    print("═" * 64)
+
+
+# ============================================================================
+# SECTION 10: LoRA Fine-Tuning Setup (Optional)
+# ============================================================================
+
+def setup_lora_training(
+    model,
+    lora_r: int = 16,
+    lora_alpha: int = 32,
+    lora_dropout: float = 0.05,
+    target_modules: Optional[List[str]] = None,
+):
+    """
+    Setup LoRA for parameter-efficient fine-tuning of the surgery model.
+    """
+    try:
+        from peft import LoraConfig, get_peft_model, TaskType
+    except ImportError:
+        raise ImportError("pip install peft")
+
+    if target_modules is None:
+        target_modules = [
+            "surgery_module.swiglu_gate",
+            "surgery_module.swiglu_up",
+            "surgery_module.output_proj",
+            "acoustic_connector.fc1",
+            "acoustic_connector.fc2",
+            "semantic_connector.fc1",
+            "semantic_connector.fc2",
+        ]
+
+    lora_config = LoraConfig(
+        r=lora_r,
+        lora_alpha=lora_alpha,
+        lora_dropout=lora_dropout,
+        target_modules=target_modules,
+        bias="none",
+        task_type=TaskType.CAUSAL_LM,
+    )
+
+    peft_model = get_peft_model(model, lora_config)
+
+    trainable = sum(p.numel() for p in peft_model.parameters() if p.requires_grad)
+    total = sum(p.numel() for p in peft_model.parameters())
+    print(f"\n  LoRA Applied:")
+    print(f"  Trainable: {trainable:,} ({100 * trainable / total:.2f}%)")
+    print(f"  Total:     {total:,}")
+
+    return peft_model
+
+
+# ============================================================================
+# SECTION 11: Main Entry Point
+# ============================================================================
+
+if __name__ == "__main__":
+    modified_model = run_surgery()
+    verify_surgery(modified_model)
+    
+    print("\n" + "█" * 64)
+    print("  SURGERY COMPLETE!")
+    print(f"  Model distributed across 2 T4 GPUs")
+    print("")
+    print("  Next Steps:")
+    print("  1. Swap tokenizer to Qwen3Tokenizer (different vocab)")
+    print("  2. Fine-tune the Surgery Module + connectors")
+    print("  3. Use setup_lora_training() for LoRA fine-tuning")
+    print("  4. Use load_surgery_model() to reload later")
+    print("█" * 64)
+
+
+# ============================================================================
+# SECTION 12: Compatibility Notes
+# ============================================================================
+"""
+COMPATIBILITY ANALYSIS — Surgery vs. VibeVoice Components
+==========================================================
+
+✅ COMPATIBLE (no changes needed):
+  • VibeVoiceModel          — forward patched to force output_hidden_states=True
+  • SpeechConnector         — replaced with correct dimensions (64/128 → 2560)
+  • VibeVoiceDiffusionHead  — UNCHANGED (still expects 3584-dim conditioning)
+  • VibeVoiceAcousticTokenizerModel — UNCHANGED
+  • VibeVoiceSemanticTokenizerModel — UNCHANGED
+  • VibeVoiceTokenizerStreamingCache — UNCHANGED
+  • AudioStreamer / AsyncAudioStreamer — UNCHANGED
+  • DPMSolverMultistepScheduler — UNCHANGED
+  • sample_speech_tokens() — UNCHANGED (receives 3584-dim from surgery)
+
+⚠️  REQUIRES ATTENTION:
+  1. TOKENIZER: Qwen3 has vocab_size=151936 (vs Qwen2's 152064).
+     You MUST swap the text tokenizer to Qwen3Tokenizer:
+       from transformers import AutoTokenizer
+       tok = AutoTokenizer.from_pretrained("Qwen/Qwen3-4B-Instruct-2507")
+     The VibeVoiceProcessor wraps this tokenizer, so you need to update
+     the processor's tokenizer as well.
+
+  2. SPECIAL TOKENS: speech_start_id, speech_end_id, speech_diffusion_id
+     must be added to the Qwen3 tokenizer before use. These are NOT in
+     Qwen3's default vocab. You need to add them and resize the embedding.
+
+  3. TRAINING SCRIPT: The existing finetune_vibevoice_lora105.py uses
+     VibeVoiceForConditionalGeneration (training class), not the inference
+     class. The training class's forward() has a different signature
+     (includes diffusion loss computation). To fine-tune the surgery model,
+     you need to adapt the training script.
+
+  4. CONFIG LOADING: The saved config uses model_type="qwen3" for
+     decoder_config. The monkey-patched VibeVoiceConfig handles this,
+     but you MUST call _patch_vibevoice_config_for_qwen3() before loading.
+
+  5. WEIGHT TYING: Qwen3 uses tie_word_embeddings=True. After surgery,
+     lm_head.weight IS embed_tokens.weight (pointer sharing). If you
+     load weights separately, ensure tying is re-established.
+
+  6. GENERATE METHOD: The patched generate stores no persistent state
+     between calls. Each generate() call is independent. The surgery
+     module is called fresh for each diffusion step.
+
+  7. MULTI-GENERATE TOKEN CONSTRAINTS: The generate method constrains
+     output to valid tokens (speech_start, speech_end, speech_diffusion,
+     eos, bos). These IDs must match the Qwen3 tokenizer's vocabulary.
+"""