Backup tts_hosting 2026-04-24 16:16:42 UTC

.dockerignore

@@ -0,0 +1,8 @@
+__pycache__/
+*.pyc
+*.pyo
+*.pyd
+*.log
+.env
+.venv/
+.git/

.env.example

@@ -0,0 +1,12 @@
+# Model and auth
+MODEL_NAME=Mevearth2/Quantized-Merged-TTS
+HF_TOKEN=
+
+# Service behavior
+MAX_INFLIGHT_REQUESTS=2
+TTS_TEMPERATURE=0.4
+TTS_TOP_P=0.9
+TTS_REPETITION_PENALTY=1.05
+TTS_MAX_SEQ_LENGTH=2048
+TTS_MAX_WORDS=50
+TTS_DENOISE=false

.gitignore

@@ -0,0 +1,8 @@
+.env
+__pycache__/
+*.pyc
+*.pyo
+*.pyd
+.venv/
+.vscode/
+*.log

.source_README.md

@@ -0,0 +1,297 @@
+---
+base_model:  snorbyte/snorTTS-Indic-v0
+tags:
+    - text-to-speech
+    - tts
+    - transformers
+    - unsloth
+    - llama
+    - audio
+    - speech-synthesis
+license: apache-2.0
+language:
+    - hi
+    - gu
+    - mr
+    - pa
+    - bn
+    - te
+    - kn
+    - ml
+    - ta
+---
+
+# snorTTS-Indic-v0
+snorTTS-Indic-v0 is a multilingual Indic Text-to-Speech (TTS) model capable of generating speech in nine Indic languages: Hindi, Tamil, Telugu, Marathi, Kannada, Malayalam, Punjabi, Gujarati, and Bengali.
+
+👉 [Read the full blog: *Train a SoTA Multilingual Indic Text-to-Speech (TTS)*](https://snorbyte.com/blog/train-sota-multilingual-indic-tts) to learn how we built it.
+
+👉 [Try out the model in our playground](https://snorbyte.com/snortts-indic-v0).
+
+All code, datasets, and models—both base and fine-tuned—used in this work are available below for anyone to use and build upon.
+
+<video controls preload="metadata"
+       src="https://gamespaces.store/demo-142-2.mp4"
+       style="width:100%;border-radius:0.75rem;margin:1rem 0;">
+</video>
+
+## Capabilities
+
+- TTS
+- Voice-Cloning
+- Code Switching
+- Cross-lingual Voice Cloning (Multilingual Voice Transfer)
+
+## Model Overview
+| Item                   | Details                                                                                                                    |
+|------------------------|----------------------------------------------------------------------------------------------------------------------------|
+| **Architecture**       | LLaMA-3.2-3B                                                                                                               |
+| **Base model**         | `canopylabs/3b-hi-pretrain-research_release`                                                                               |
+| **Audio codec**        | SNAC @ 24 kHz, 3 codebooks (12,288 new tokens)                                                                             |
+| **Languages**          | Hindi, Gujarati, Marathi, Punjabi, Bengali, Telugu, Kannada, Malayalam, Tamil                                              |
+
+
+## Training
+
+For details about the training and dataset, please refer to [*Train a SoTA Multilingual Indic Text-to-Speech (TTS)*](https://snorbyte.com/blog/train-sota-multilingual-indic-tts).
+
+You can find the training script (`train_orepheus.py`) in this repository. It is a single, self-contained script for fine-tuning the base model.
+
+👉 Dataset used for training: [snorbyte/indic-tts-sample-snac-encoded](https://huggingface.co/datasets/snorbyte/indic-tts-sample-snac-encoded)
+
+## Inference 
+
+👉 To host in Modal: Check the ```modal``` folder
+
+- Install necessary libraries for linux
+```bash
+sudo apt update
+```
+```bash
+sudo apt install -y sox libsox-dev  
+```
+- Use Python 3.10
+- If you already have torch installed, uninstall it. Let unsloth take care of it.
+```bash
+pip uninstall -y torch torchaudio 
+```
+- Install necessary packages
+```bash
+pip install unsloth loguru snac deepfilternet pydub soundfile librosa torchaudio
+```
+
+```python
+from unsloth import FastLanguageModel
+from snac import SNAC
+import soundfile as sf
+import numpy as np
+from loguru import logger
+from df.enhance import init_df, enhance, save_audio
+import torch
+import librosa
+import torchaudio
+import os
+
+#Name of the model
+MODEL_NAME = 'snorbyte/snorTTS-Indic-v0'
+MAX_SEQ_LENGTH = 4096
+HUGGINGFACE_TOKEN = "" # ! Add your hugging face token
+
+# Load the model and tokenizer.
+model, tokenizer = FastLanguageModel.from_pretrained(
+    model_name=MODEL_NAME,
+    # load_in_4bit=True,
+    max_seq_length=MAX_SEQ_LENGTH,
+    token=HUGGINGFACE_TOKEN,
+)
+logger.success(f"Loaded model: {MODEL_NAME}")
+
+
+# Load the end of speech token for the tokenizer.
+tokeniser_length = 128256
+end_of_speech_id = tokeniser_length + 2
+pad_token_id = tokeniser_length + 7
+audio_start_id = tokeniser_length + 10
+
+pad_token = tokenizer.decode([pad_token_id])
+logger.success("Load special tokens for the tokenizer.")
+
+# Wrap Model for Inference
+FastLanguageModel.for_inference(model)
+logger.success(f"{MODEL_NAME} is ready for inference.")
+
+# Set the padding token and padding side.
+tokenizer.pad_token = pad_token
+tokenizer.padding_side = "left"
+logger.success("Set padding token and padding side for the tokenizer.")
+
+# Load the SNAC model for audio decoding.
+snac_model = SNAC.from_pretrained("hubertsiuzdak/snac_24khz")
+logger.success("Loaded SNAC model for audio decoding.")
+
+# Load DeepFilter for optional post processing
+df_model, df_state, _ = init_df()
+
+# Function to generate audio
+def generate_audio(
+    row, model, tokenizer, user=False, temperature=0.4, top_p=0.9, repetition_penalty=1.05
+):
+    try:
+        if user:
+            prompt = row["eval_text_user"]
+        else:
+            prompt = row["eval_text_no_user"]
+        inputs = tokenizer(prompt, add_special_tokens=False, return_tensors="pt")
+        max_tokens = MAX_SEQ_LENGTH - inputs.input_ids.shape[1]
+        output = model.generate(
+            input_ids=inputs.input_ids.to("cuda"),
+            attention_mask=inputs.attention_mask.to("cuda"),
+            max_new_tokens=max_tokens,
+            temperature=temperature,
+            top_p=top_p,
+            repetition_penalty=repetition_penalty,
+            eos_token_id=end_of_speech_id,
+        )
+        audio_ids = []
+        for id in output[0]:
+            if id >= audio_start_id:
+                audio_ids.append(id.item())
+        clean_audio_ids = []
+        for i in range((len(audio_ids) + 1) // 7):
+            for j in range(7):
+                clean_audio_ids += [audio_ids[7 * i + j] - audio_start_id]
+        codes = [[], [], []]
+        for i in range((len(clean_audio_ids) + 1) // 7):
+            codes[0].append(clean_audio_ids[7 * i])
+            codes[1].append(clean_audio_ids[7 * i + 1] - 4096)
+            codes[2].append(clean_audio_ids[7 * i + 2] - (2 * 4096))
+            codes[2].append(clean_audio_ids[7 * i + 3] - (3 * 4096))
+            codes[1].append(clean_audio_ids[7 * i + 4] - (4 * 4096))
+            codes[2].append(clean_audio_ids[7 * i + 5] - (5 * 4096))
+            codes[2].append(clean_audio_ids[7 * i + 6] - (6 * 4096))
+        codes = [
+            torch.tensor(codes[0]).unsqueeze(0),
+            torch.tensor(codes[1]).unsqueeze(0),
+            torch.tensor(codes[2]).unsqueeze(0),
+        ]
+        try:
+            audio = snac_model.decode(codes)
+        except Exception as e:
+            logger.error(f"Error decoding audio: {e}")
+            return None
+        return audio.detach().squeeze().to("cpu").numpy()
+    except Exception as e:
+        logger.error(f"Error decoding audio: {e}")
+        return None
+
+# Run inference.
+# * Please refer to the training script to create prompt from SNAC tokens.
+row = {
+    "eval_text_user": f"<custom_token_3><|begin_of_text|>kannada142: ಅಯ್ಯಯ್ಯೋ... Whitefield ಗೆ reach ಆಗೋಕೆ almost 10 hours ಆಯ್ತು you know... traffic was so terrible today <|eot_id|><custom_token_4><custom_token_5><custom_token_1>"
+    }
+
+eval_sample = generate_audio(row, model, tokenizer, True)
+if eval_sample is None:
+    logger.error("Failed to generate audio for evaluation sample.")
+else:
+    logger.success("Audio Generated. Post Processing Started")
+
+    ## post-processing settings
+    filename = "eval.wav"
+    speed = 1.05 #add speed up according to speaker
+    denoise = False #denoise if you want
+    output = eval_sample.astype(np.float32) 
+
+    #speed up
+    if abs(speed - 1.0) > 1e-4:
+        output_t = torch.from_numpy(output).unsqueeze(0) 
+        output_speed, _ = torchaudio.sox_effects.apply_effects_tensor(output_t, 24_000, effects=[["tempo", f"{speed}"]])
+        output = output_speed.squeeze(0).cpu().numpy()
+    
+    #denoise
+    if denoise:
+        resampled_48k = librosa.resample(output, orig_sr=24_000, target_sr=48_000)
+        resampled_48k = torch.from_numpy(resampled_48k).unsqueeze(0)
+        output_48k = enhance(df_model, df_state, resampled_48k)
+        output_48k = output_48k.squeeze(0).cpu().numpy() 
+        output = librosa.resample(output_48k, orig_sr=48_000, target_sr=24_000)
+        
+    logger.success("Saving Final Output...")
+     
+    #save
+    sf.write(filename, output, 24_000)   
+
+    logger.success(f"Generated and saved evaluation sample audio as {filename}.")
+```
+
+## Prompts
+
+- **Standard**
+
+```python
+{
+    "eval_text_no_user": f"<custom_token_3><|begin_of_text|>{utterance}<|eot_id|><custom_token_4><custom_token_5><custom_token_1>"
+}
+```
+
+```python
+{
+    "eval_text_no_user": f"<custom_token_3><|begin_of_text|>நிச்சயமா. ரோம் ல் இரவு நேரம் ரொம்ப அழகா இருக்கு—piazzaகள் சுத்துறதுக்கு நல்ல நேரம்.<|eot_id|><custom_token_4><custom_token_5><custom_token_1>"
+},
+```
+
+- **Speaker Specific**: (Recommended)
+
+```python
+{
+    "eval_text_user": f"<custom_token_3><|begin_of_text|>{language}{speaker_id}: {utterance}<|eot_id|><custom_token_4><custom_token_5><custom_token_1>"
+}
+```
+
+> 📝 `utterance` can be in native language of the speaker, multi-lingual, or code-switched as well.
+
+```python
+{
+    "eval_text_user": f"<custom_token_3><|begin_of_text|>hindi159:  चलते रहो इस सफर में बिना रुके, क्योंकि मंज़िलें खुद राह दिखाने लगती हैं <|eot_id|><custom_token_4><custom_token_5><custom_token_1>"
+}
+```
+
+```python
+{
+    "eval_text_user": f"<custom_token_3><|begin_of_text|>bengali125: मुझे तो लगा वो आएगा, ஆனா அவன் வந்து full drama பண்ணிட்டான், আর শেষে আবার আমাকে দোষ দিচ্ছে <|eot_id|><custom_token_4><custom_token_5><custom_token_1>"
+}
+```
+
+
+### Speaker IDs
+
+| Language  | Speakers         | Recommended Speedup  |
+|-----------|------------------|----------------------|
+| Hindi     | [159,49,43]      | [1.05,1.1,1.1]       |
+| Tamil     | [188,128,176]    | [1.1,1.15,1.1]       |
+| Bengali   | [125]            | [1.1]                |
+| Malayalam | [189,124]        | [1.1,1.1]            |
+| Kannada   | [142,138,131,59] | [1.05,1.1,1.1,1.1]   |
+| Telugu    | [69,133]         | [1.1,1.1]            |
+| Punjabi   | [191,67,201]     | [1.08,1.06,1.1]      |
+| Gujarati  | [62,190]         | [1.15,1.25]          |
+| Marathi   | [205,82,199,203] | [1.05,1.05,1.1,1.15] |
+
+## Contact Us
+👉 Mail: [founders@snorbyte.com](mailto:founders@snorbyte.com)
+
+👉 Website: [https://snorbyte.com](https://snorbyte.com)
+
+## Citation
+
+BibTeX:
+
+```bibtex
+@misc{indictextaudio2025,
+  title={snorTTS-Indic-v0: Multilingual Indic TTS},
+  author={snorbyte},
+  year={2025},
+  howpublished={\url{snorbyte/snorTTS-Indic-v0}},
+  note={Apache-2.0}
+}
+```

.source_modal__snorTTS_Indic_v0_server.py

@@ -0,0 +1,413 @@
+# * Install Modal.
+# uv run pip install modal
+
+# * Setup Modal.
+# uv run modal setup
+
+# * Run to deploy the Modal app.
+# uv run modal deploy scripts/modal/snorTTS_Indic_v0_server.py
+
+# * Test.
+# curl -X 'POST' \
+#   'https://snorbyte--snortts-indic-v0-server-prod-ttsserver-serve.modal.run/?utterance=%E0%A4%95%E0%A4%B2%20%E0%A4%AE%E0%A5%88%E0%A4%82%E0%A4%A8%E0%A5%87%20%E0%A4%B8%E0%A4%BF%E0%A4%B0%E0%A5%8D%E0%A4%AB%20%E2%82%B9500%20%E0%A4%AE%E0%A5%87%E0%A4%82%20%E0%A4%8F%E0%A4%95%20cool%20headphones%20%E0%A4%B2%E0%A5%87%20%E0%A4%B2%E0%A4%BF%E0%A4%8F%2C%20%E0%A4%AC%E0%A4%B9%E0%A5%81%E0%A4%A4%20%E0%A4%AC%E0%A4%A2%E0%A4%BC%E0%A4%BF%E0%A4%AF%E0%A4%BE%20deal%20%E0%A4%A5%E0%A4%BE%20%E0%A4%AF%E0%A4%BE%E0%A4%B0%21&user_id=159&language=hindi&temperature=0.4&top_p=0.9&repetition_penalty=1.05&speed=1.05&denoise=true&stream=false' \
+#   -H 'accept: audio/mpeg' \
+#   -d '' \
+#   --output outputs/output_non_stream.mp3
+
+# curl -X 'POST' \
+#   'https://snorbyte--snortts-indic-v0-server-prod-ttsserver-serve.modal.run/?utterance=%E0%A4%95%E0%A4%B2%20%E0%A4%AE%E0%A5%88%E0%A4%82%E0%A4%A8%E0%A5%87%20%E0%A4%B8%E0%A4%BF%E0%A4%B0%E0%A5%8D%E0%A4%AB%20%E2%82%B9500%20%E0%A4%AE%E0%A5%87%E0%A4%82%20%E0%A4%8F%E0%A4%95%20cool%20headphones%20%E0%A4%B2%E0%A5%87%20%E0%A4%B2%E0%A4%BF%E0%A4%8F%2C%20%E0%A4%AC%E0%A4%B9%E0%A5%81%E0%A4%A4%20%E0%A4%AC%E0%A4%A2%E0%A4%BC%E0%A4%BF%E0%A4%AF%E0%A4%BE%20deal%20%E0%A4%A5%E0%A4%BE%20%E0%A4%AF%E0%A4%BE%E0%A4%B0%21&user_id=159&language=hindi&temperature=0.4&top_p=0.9&repetition_penalty=1.05&speed=1.05&denoise=true&stream=true' \
+#   -H 'accept: audio/mpeg' \
+#   -d '' \
+#   --output outputs/output_stream.mp3
+
+# Import Modal.
+import modal
+
+
+# Define constants.
+APP_NAME = "snorTTS-Indic-v0-server-prod"
+SCALEDOWN_WINDOW = 15 * 60
+TIMEOUT = 10 * 60
+MIN_CONTAINERS = 1
+MAX_CONTAINERS = 1
+MAX_CONCURRENT_REQUESTS = 5
+
+
+# Define the Docker image.
+image = (
+    modal.Image.debian_slim(python_version="3.12")
+    .apt_install(
+        "curl",  # Install curl for downloading files.
+        "ffmpeg",  # Install ffmpeg for audio processing.
+        "git",  # Install git for version control.
+        "libsox-dev",  # Install SoX for audio processing.
+    )
+    .run_commands(
+        "curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y",  # Install Rust.
+    )
+    .env(
+        {
+            "PATH": "/root/.cargo/bin:${PATH}",  # Add Rust to PATH.
+            "HF_HUB_ENABLE_HF_TRANSFER": "1",  # Set `HF_HUB_ENABLE_HF_TRANSFER` for fast model transfers.
+        }
+    )
+    .pip_install(
+        "deepfilternet",  # Install DeepFilterNet for audio denoising.
+        "fastapi[standard]",  # Install FastAPI for building the API.
+        "hf_transfer",  # Install Hugging Face transfer for fast model transfers.
+        "loguru",  # Install Loguru for logging.
+        "numpy",  # Install NumPy for numerical operations.
+        "pydub",  # Install Pydub for audio processing.
+        "snac",  # Install SNAC for audio decoding.
+        "torchaudio",  # Install Torchaudio for audio processing.
+        "transformers",  # Install Transformers for model handling.
+    )
+)
+
+# Create the Modal app.
+app = modal.App(APP_NAME, image=image)
+
+with image.imports():
+    # Import necessary libraries for the remote function.
+    from typing import Any
+    import aiohttp
+    import io
+    import json
+
+    from df.enhance import init_df, enhance
+    from fastapi.responses import StreamingResponse
+    from loguru import logger
+    from pydub import AudioSegment
+    from snac import SNAC
+    from transformers import AutoTokenizer
+    import numpy as np
+    import torch
+    import torchaudio as ta
+
+
+@app.cls(
+    cpu=4.0,  # Set number of CPU cores.
+    memory=8192,  # Set memory in MiB.
+    scaledown_window=SCALEDOWN_WINDOW,  # Set how long should we stay up with no requests.
+    timeout=TIMEOUT,  # Set the timeout for the function.
+    enable_memory_snapshot=True,  # Enable memory snapshot for better cold boot times.
+    min_containers=MIN_CONTAINERS,  # Minimum number of containers to keep running.
+    max_containers=MAX_CONTAINERS,  # Maximum number of containers to run.
+)
+@modal.concurrent(
+    max_inputs=MAX_CONCURRENT_REQUESTS
+)  # Limit the number of concurrent requests.
+class TTSServer:
+    @modal.enter()
+    def load(self) -> None:
+        # Load the tokenizer.
+        self.tokenizer = AutoTokenizer.from_pretrained("snorbyte/snorTTS-Indic-v0")
+        logger.success("Loaded tokenizer from snorbyte/snorTTS-Indic-v0.")
+
+        # Token related bookkeeping.
+        # Set the tokenizer length.
+        self.tokeniser_length = 128256
+        logger.success("Set tokenizer length.")
+
+        # Set the end of speech ID, pad token ID, and audio start ID.
+        self.end_of_speech_id = self.tokeniser_length + 2
+        self.pad_token_id = self.tokeniser_length + 7
+        self.audio_start_id = self.tokeniser_length + 10
+        logger.success("Set end of speech ID, pad token ID, and audio start ID.")
+
+        # Decode the pad token.
+        self.pad_token = self.tokenizer.decode([self.pad_token_id])
+        logger.success("Decoded pad token.")
+
+        # Set the padding token and padding side.
+        self.tokenizer.pad_token = self.pad_token
+        self.tokenizer.padding_side = "left"
+        logger.success("Set padding token and padding side for the tokenizer.")
+
+        # Models.
+        # Load the SNAC model for audio decoding.
+        self.snac_model = SNAC.from_pretrained("hubertsiuzdak/snac_24khz")
+        logger.success("Loaded SNAC model for audio decoding.")
+
+        # Initialize the DF model for audio denoising.
+        self.df_model, self.df_state, _ = init_df()
+        logger.success("Initialized DF model for audio denoising.")
+
+    async def _decode_audio(self, audio_ids: list[int], speed: float, denoise: bool):
+        # Offset the audio tokens by the audio start ID.
+        snac_audio_ids = []
+        for i in range((len(audio_ids) + 1) // 7):
+            for j in range(7):
+                snac_audio_ids += [audio_ids[7 * i + j] - self.audio_start_id]
+
+        # Prepare the codes for SNAC decoding.
+        # ! Please note: codes cannot be negative. If the model generates incorrect codes
+        # ! at the wrong positions, audio generation will fail.
+        codes = [[], [], []]
+        for i in range((len(snac_audio_ids) + 1) // 7):
+            codes[0].append(snac_audio_ids[7 * i])
+            codes[1].append(snac_audio_ids[7 * i + 1] - 4096)
+            codes[2].append(snac_audio_ids[7 * i + 2] - (2 * 4096))
+            codes[2].append(snac_audio_ids[7 * i + 3] - (3 * 4096))
+            codes[1].append(snac_audio_ids[7 * i + 4] - (4 * 4096))
+            codes[2].append(snac_audio_ids[7 * i + 5] - (5 * 4096))
+            codes[2].append(snac_audio_ids[7 * i + 6] - (6 * 4096))
+        codes = [
+            torch.tensor(codes[0]).unsqueeze(0),
+            torch.tensor(codes[1]).unsqueeze(0),
+            torch.tensor(codes[2]).unsqueeze(0),
+        ]
+
+        try:
+            # Decode the audio using SNAC.
+            audio = self.snac_model.decode(codes).reshape(1, -1)
+            logger.success(f"Decoded {len(snac_audio_ids)} SNAC tokens to audio.")
+        except Exception as e:
+            logger.error(f"Error decoding audio: {e}")
+            return None
+
+        # Speed up or slow down the audio.
+        if abs(speed - 1.0) > 1e-4:
+            try:
+                audio, _ = ta.sox_effects.apply_effects_tensor(
+                    audio, 24_000, effects=[["tempo", f"{speed}"]]
+                )
+                logger.success(
+                    f"Applied speed effect to audio with speed factor {speed}."
+                )
+            except Exception as e:
+                logger.error(f"Error applying speed effect: {e}")
+                return None
+
+        # Denoise the audio.
+        if denoise:
+            try:
+                audio = ta.transforms.Resample(orig_freq=24_000, new_freq=48_000)(audio)
+                audio = enhance(self.df_model, self.df_state, audio)
+                audio = ta.transforms.Resample(orig_freq=48_000, new_freq=24_000)(audio)
+                logger.success("Denoised audio using DeepFilterNet.")
+            except Exception as e:
+                logger.error(f"Error denoising audio: {e}")
+                return None
+
+        # Move the audio to CPU and convert to numpy array.
+        audio = audio.detach().squeeze().cpu().numpy()
+
+        return audio
+
+    async def _generate(
+        self,
+        utterance: str,
+        user_id: str = 159,
+        language: str = "hindi",
+        temperature: float = 0.4,
+        top_p: float = 0.9,
+        repetition_penalty: float = 1.05,
+        speed: float = 1.05,
+        denoise: bool = False,
+        stream: bool = True,
+    ):
+        try:
+            # Limit the utterance length to 50 words.
+            utterance = " ".join(utterance.split(" ")[:50])
+
+            logger.info(
+                f"Generating audio for utterance, {utterance}, user_id, {user_id}, language, {language}, "
+                f"temperature, {temperature}, top_p, {top_p}, repetition_penalty, {repetition_penalty}, "
+                f"speed, {speed}, denoise, {denoise} and stream, {stream}."
+            )
+
+            # Create the prompt.
+            prompt = f"<custom_token_3><|begin_of_text|>{language}{user_id}: {utterance}<|eot_id|><custom_token_4><custom_token_5><custom_token_1>"
+
+            # Tokenize the prompt.
+            inputs = self.tokenizer(prompt, add_special_tokens=False)
+
+            # Set max audio tokens to generate.
+            max_tokens = 2048 - len(inputs.input_ids)
+
+            # Generate the output.
+            async with aiohttp.ClientSession(
+                base_url="https://snorbyte--snortts-indic-v0-vllm-prod-serve.modal.run"
+            ) as session:
+                # Prepare the payload for the vLLM server.
+                # ! Without type hinting the vLLM server will not recognize the request.
+                payload: dict[str, Any] = {
+                    "prompt": prompt,
+                    "model": "llm",
+                    "stream": True,
+                    "temperature": 0.4,
+                    "top_p": 0.9,
+                    "max_tokens": max_tokens,
+                    "repetition_penalty": 1.05,
+                    "add_special_tokens": False,
+                    "stop_token_ids": [128258],
+                }
+
+                # Set the headers for the request.
+                headers = {
+                    "Content-Type": "application/json",
+                    "Accept": "text/event-stream",
+                }
+
+                # Initialize the audio tokens list.
+                audio_ids = []
+
+                # Send the request to the vLLM server to generate audio.
+                async with session.post(
+                    "/v1/completions",
+                    json=payload,
+                    headers=headers,
+                    timeout=1 * 60,
+                ) as resp:
+                    # Maintine a buffer for the audio data.
+                    buffer = io.BytesIO()
+
+                    # Stream the vLLM response.
+                    async for raw in resp.content:
+                        # Check if the response is successful.
+                        resp.raise_for_status()
+
+                        # Decode bytes.
+                        line = raw.decode().strip()
+
+                        # Skip empty lines and end of stream.
+                        if not line or line == "data: [DONE]":
+                            continue
+
+                        # Remove the "data: " prefix if present.
+                        if line.startswith("data: "):
+                            line = line[len("data: ") :]
+
+                        # Parse the JSON response.
+                        chunk = json.loads(line)
+
+                        # Tokenize the generated tokens.
+                        output = self.tokenizer(
+                            chunk["choices"][0]["text"], add_special_tokens=False
+                        ).input_ids
+
+                        # Extract audio tokens from the output.
+                        for id in output:
+                            if id >= self.audio_start_id:
+                                audio_ids.append(id)
+
+                        # If streaming is enabled and the audio_ids list has more than 168 tokens,
+                        # decode and yield the audio.
+                        # ! This will lead to jittering in the audio stream.
+                        if stream and len(audio_ids) > 168:
+                            # Decode tokens to audio.
+                            audio = await self._decode_audio(audio_ids, speed, denoise)
+
+                            if audio is not None:
+                                # Write the audio to the buffer.
+                                # Convert to int16 PCM format expected by AudioSegment.
+                                audio_int16 = (audio * 32767).astype(np.int16)
+
+                                # Create raw audio segment.
+                                raw_audio = AudioSegment(
+                                    audio_int16.tobytes(),
+                                    frame_rate=24000,
+                                    sample_width=2,
+                                    channels=1,
+                                )
+
+                                # Export the audio to the buffer in MP3 format.
+                                raw_audio.export(buffer, format="mp3", bitrate="96k")
+
+                                # Reset the buffer's internal pointer to the beginning of the stream.
+                                # This allows reading the entire content from the start.
+                                buffer.seek(0)
+
+                                # Read the entire contents of the buffer into the `data` variable.
+                                audio_data = buffer.read()
+
+                                # Move the buffer's internal pointer back to the beginning again.
+                                # This is done to prepare it for clearing.
+                                buffer.seek(0)
+
+                                # Truncate the buffer, effectively removing all contents.
+                                # This clears it for reuse with new audio data.
+                                buffer.truncate(0)
+
+                                # Yield the audio data.
+                                yield audio_data
+
+                                # Keep the last incomplete frame.
+                                last_index = len(audio_ids) % 7
+                                if last_index == 0:
+                                    audio_ids = []
+                                else:
+                                    audio_ids = audio_ids[-last_index:]
+
+                    # Check if there are any remaining audio tokens to process.
+                    if audio_ids:
+                        # Decode tokens to audio.
+                        audio = await self._decode_audio(audio_ids, speed, denoise)
+
+                        if audio is not None:
+                            # Write the audio to the buffer.
+                            # Convert to int16 PCM format expected by AudioSegment.
+                            audio_int16 = (audio * 32767).astype(np.int16)
+
+                            # Create raw audio segment.
+                            raw_audio = AudioSegment(
+                                audio_int16.tobytes(),
+                                frame_rate=24000,
+                                sample_width=2,
+                                channels=1,
+                            )
+
+                            # Export the audio to the buffer in MP3 format.
+                            raw_audio.export(buffer, format="mp3", bitrate="96k")
+
+                            # Reset the buffer's internal pointer to the beginning of the stream.
+                            # This allows reading the entire content from the start.
+                            buffer.seek(0)
+
+                            # Read the entire contents of the buffer into the `data` variable.
+                            audio_data = buffer.read()
+
+                            # Move the buffer's internal pointer back to the beginning again.
+                            # This is done to prepare it for clearing.
+                            buffer.seek(0)
+
+                            # Truncate the buffer, effectively removing all contents.
+                            # This clears it for reuse with new audio data.
+                            buffer.truncate(0)
+
+                            # Yield the audio data.
+                            yield audio_data
+        except Exception as e:
+            logger.exception(f"Error during audio generation: {e}")
+
+    @modal.fastapi_endpoint(
+        docs=True, method="POST"
+    )  # Define a FastAPI endpoint for TTS.
+    async def serve(
+        self,
+        utterance: str,
+        user_id: str = 159,
+        language: str = "hindi",
+        temperature: float = 0.4,
+        top_p: float = 0.9,
+        repetition_penalty: float = 1.05,
+        speed: float = 1.05,
+        denoise: bool = False,
+        stream: bool = True,
+    ):
+        # Stream the generated audio as an MP3 response.
+        return StreamingResponse(
+            self._generate(
+                utterance,
+                user_id=user_id,
+                language=language,
+                temperature=temperature,
+                top_p=top_p,
+                repetition_penalty=repetition_penalty,
+                speed=speed,
+                denoise=denoise,
+                stream=stream,
+            ),
+            media_type="audio/mpeg",
+        )

.source_modal__snorTTS_Indic_v0_vllm.py

@@ -0,0 +1,96 @@
+# * Install Modal.
+# uv run pip install modal
+
+# * Setup Modal.
+# uv run modal setup
+
+# * Run to deploy the Modal app.
+# uv run modal deploy scripts/modal/snorTTS_Indic_v0_vllm.py
+
+# Import Modal.
+import modal
+
+
+# Define constants.
+MODEL_NAME = "snorbyte/snorTTS-Indic-v0"
+MAX_SEQ_LEN = 2048
+MAX_CONCURRENT_SEQS = 5
+APP_NAME = "snorTTS-Indic-v0-vllm-prod"
+SCALEDOWN_WINDOW = 15 * 60
+TIMEOUT = 10 * 60
+VLLM_PORT = 8000
+GPU = "T4"
+MIN_CONTAINERS = 1
+MAX_CONTAINERS = 1
+MAX_CONCURRENT_REQUESTS = MAX_CONCURRENT_SEQS
+
+# Define the Docker image.
+image = (
+    modal.Image.debian_slim(python_version="3.12")
+    .pip_install(
+        "vllm==0.9.1",  # Install vLLM for serving models.
+        "huggingface_hub[hf_transfer]==0.32.0",  # Install Hugging Face transfer for fast model transfers.
+        "flashinfer-python==0.2.6.post1",  # Install FlashInfer for optimized inference.
+        extra_index_url="https://download.pytorch.org/whl/cu128",  # Use pytorch's extra index url for flashinfer.
+    )
+    .env(
+        {
+            "HF_HUB_ENABLE_HF_TRANSFER": "1",  # Set `HF_HUB_ENABLE_HF_TRANSFER` for fast model transfers.
+        }
+    )
+)
+
+# Setup volumes for cache.
+hf_cache_vol = modal.Volume.from_name("huggingface-cache", create_if_missing=True)
+vllm_cache_vol = modal.Volume.from_name("vllm-cache", create_if_missing=True)
+
+# Create the Modal app.
+app = modal.App(APP_NAME)
+
+
+with image.imports():
+    # Import necessary libraries for the remote function.
+    import subprocess
+
+
+# Define the function to start the VLLM server.
+@app.function(
+    image=image,  # Set the image for the function.
+    gpu=GPU,  # Set the GPU type for the instance.
+    scaledown_window=SCALEDOWN_WINDOW,  # Set how we long should we stay up with no requests.
+    timeout=TIMEOUT,  # Set the timeout for the function.
+    volumes={
+        "/root/.cache/huggingface": hf_cache_vol,
+        "/root/.cache/vllm": vllm_cache_vol,
+    },  # Set the volumes for cache.
+    min_containers=MIN_CONTAINERS,  # Minimum number of containers to keep running.
+    max_containers=MAX_CONTAINERS,  # Maximum number of containers to run.
+)
+@modal.concurrent(
+    max_inputs=MAX_CONCURRENT_REQUESTS
+)  # Limit the number of concurrent requests.
+@modal.web_server(
+    port=VLLM_PORT, startup_timeout=TIMEOUT
+)  # Expose the VLLM server on the specified port.
+def serve():
+    # Create the command to start the VLLM server.
+    cmd = [
+        "vllm",
+        "serve",
+        "--uvicorn-log-level=info",
+        MODEL_NAME,
+        "--served-model-name",
+        MODEL_NAME,
+        "llm",
+        "--max-model-len",
+        str(MAX_SEQ_LEN),
+        "--max-num-seqs",
+        str(MAX_CONCURRENT_SEQS),
+        "--host",
+        "0.0.0.0",
+        "--port",
+        str(VLLM_PORT),
+    ]
+
+    # Start the VLLM server using subprocess.
+    subprocess.Popen(" ".join(cmd), shell=True)

.source_train_llama.py

@@ -0,0 +1,383 @@
+# * This script was not rigorously tested, so it may not work as expected. We would suggest to
+# * edit the script to follow Orpheus training script.
+
+# * Install unsloth, PEFT, Weights & Biases, SNAC, pandas, soundfile and loguru.
+# !pip install unsloth peft==0.15.2 wandb snac pandas soundfile loguru
+
+# * Login to Weights & Biases.
+# !wandb login
+
+# Import necessary libraries.
+# * unsloth import should always be at the top.
+from unsloth import FastLanguageModel
+
+import os
+
+from datasets import load_dataset
+from huggingface_hub import login
+from loguru import logger
+from snac import SNAC
+from trl import SFTConfig, SFTTrainer
+import soundfile as sf
+import torch
+import wandb
+
+
+# Set up constants and configurations.
+HUGGINGFACE_USERNAME = ""  # ! Fill.
+BASE_MODEL = "meta-llama/Llama-3.2-3B-Instruct"
+TRAIN_CSV_PATH = "data/data_stage_1.csv"
+VALID_CSV_PATH = "data/data_eval.csv"
+TRAIN_NUM_SAMPLES = None
+EVAL_NUM_SAMPLES = None
+MAX_SEQ_LENGTH = 2048
+N_CODEBOOKS, CODEBOOK_SIZE = 3, 4096
+FIELDS = [
+    "user",
+    "gender",
+    "age",
+    "language",
+    "utterance",
+    "audio",
+]
+START_OF_SPECIAL_TOKENS = {field: f"<|start_of_{field}|>" for field in FIELDS}
+END_OF_SPECIAL_TOKENS = {field: f"<|end_of_{field}|>" for field in FIELDS}
+SNAC_TOKENS = [
+    f"<|snac_{i}_{j}|>" for i in range(N_CODEBOOKS) for j in range(CODEBOOK_SIZE)
+]
+PER_DEVICE_TRAIN_BATCH_SIZE = 8
+GRADIENT_ACCUMULATION_STEPS = 4
+FULL_FINETUNING = True  # Set to False for LoRA training.
+MODEL_NAME = "indic-tts-lora-training"
+WANDB_USERNAME = ""  # ! Fill.
+WANDB_PROJECT = "indic-tts-lora-training"
+WANDB_LOG_MODEL = "checkpoint"
+WANDB_RUN_NAME = None
+WANDB_RUN_ID = None
+SEED = 3407
+HUGGINGFACE_TOKEN = ""  # ! Fill.
+WANDB_TOKEN = ""  # ! Fill.
+
+# * Use the following command to start the training: python train_llama.py
+
+# Login to Hugging Face.
+login(token=HUGGINGFACE_TOKEN)
+
+# Login to Weights & Biases.
+wandb.login(key=WANDB_TOKEN)
+
+# Set up environment variables for Weights & Biases.
+os.environ["WANDB_PROJECT"] = WANDB_PROJECT
+os.environ["WANDB_LOG_MODEL"] = WANDB_LOG_MODEL
+
+# Load the model and tokenizer.
+model, tokenizer = FastLanguageModel.from_pretrained(
+    model_name=BASE_MODEL,
+    load_in_4bit=not FULL_FINETUNING,
+    max_seq_length=MAX_SEQ_LENGTH,
+    full_finetuning=FULL_FINETUNING,
+)
+logger.success(f"Loaded model: {BASE_MODEL}")
+
+# Set the end of sequence token.
+EOS_TOKEN = tokenizer.eos_token
+
+# Add new special tokens to the tokenizer.
+new_special_tokens = (
+    list(START_OF_SPECIAL_TOKENS.values())
+    + list(END_OF_SPECIAL_TOKENS.values())
+    + SNAC_TOKENS
+)
+tokenizer.add_tokens(new_special_tokens, special_tokens=True)
+model.resize_token_embeddings(len(tokenizer))
+snac_offset = len(tokenizer.get_vocab()) - len(SNAC_TOKENS)
+logger.success("Added new special tokens to the tokenizer.")
+
+if not FULL_FINETUNING:
+    # Get parameter efficient fine-tuning model.
+    model = FastLanguageModel.get_peft_model(
+        model,
+        r=192,
+        target_modules=[
+            "q_proj",
+            "k_proj",
+            "v_proj",
+            "o_proj",
+            "up_proj",
+            "down_proj",
+            "gate_proj",
+            "lm_head",
+            "embed_tokens",
+        ],
+        lora_alpha=384,
+        random_state=SEED,
+    )
+    logger.success("Initialized parameter efficient fine-tuning model.")
+
+# Load training and validation datasets.
+# The dataset should be in CSV format with columns user (str), language (str), utterance (str), and snac_codes (list).
+train_dataset = load_dataset("csv", data_files=TRAIN_CSV_PATH)["train"]
+eval_dataset = load_dataset("csv", data_files=VALID_CSV_PATH)["train"]
+
+if TRAIN_NUM_SAMPLES:
+    train_dataset = train_dataset.shuffle(seed=SEED).select(
+        range(min(TRAIN_NUM_SAMPLES, len(train_dataset)))
+    )
+
+if EVAL_NUM_SAMPLES:
+    eval_dataset = eval_dataset.shuffle(seed=SEED).select(
+        range(min(EVAL_NUM_SAMPLES, len(eval_dataset)))
+    )
+
+logger.success(
+    f"Loaded datasets: {len(train_dataset)} training samples, {len(eval_dataset)} evaluation samples."
+)
+
+
+# Format SNAC audio codes.
+def format_snac_audio_codes(row):
+    audio_codes = row["snac_codes"]
+    if isinstance(audio_codes, str):
+        audio_codes = eval(audio_codes)
+    snac_tokens = [[], [], []]
+    for i, layer in enumerate(audio_codes):
+        for code in layer:
+            snac_tokens[i].append(f"<|snac_{i}_{code}|>")
+    row["snac_tokens"] = snac_tokens
+    return row
+
+
+train_dataset = train_dataset.map(format_snac_audio_codes)
+eval_dataset = eval_dataset.map(format_snac_audio_codes)
+logger.success("Formatted SNAC audio codes.")
+
+
+# Flatten SNAC audio codes.
+def flatten_audio_codes(row):
+    audio_codes = row["snac_tokens"]
+    flattened_codes = []
+    for i in range(len(audio_codes[0])):
+        flattened_codes.append(audio_codes[0][i])
+        flattened_codes.append(audio_codes[1][2 * i])
+        flattened_codes.append(audio_codes[2][4 * i])
+        flattened_codes.append(audio_codes[2][(4 * i) + 1])
+        flattened_codes.append(audio_codes[1][(2 * i) + 1])
+        flattened_codes.append(audio_codes[2][(4 * i) + 2])
+        flattened_codes.append(audio_codes[2][(4 * i) + 3])
+    row["snac_tokens_list"] = flattened_codes
+    return row
+
+
+train_dataset = train_dataset.map(flatten_audio_codes)
+eval_dataset = eval_dataset.map(flatten_audio_codes)
+logger.success("Flattened SNAC audio codes.")
+
+
+# Remove duplicate frames from the audio codes.
+def remove_duplicate_frames(row):
+    vals = row["snac_tokens_list"]
+    if len(vals) % 7 != 0:
+        raise ValueError("Input list length must be divisible by 7")
+    result = vals[:7]
+    for i in range(7, len(vals), 7):
+        current_first = vals[i]
+        previous_first = result[-7]
+        if current_first != previous_first:
+            result.extend(vals[i : i + 7])
+    row["snac_tokens_list"] = result
+    return row
+
+
+train_dataset = train_dataset.map(remove_duplicate_frames)
+eval_dataset = eval_dataset.map(remove_duplicate_frames)
+logger.success("Removed duplicate frames from audio codes.")
+
+
+# Define a function to format the prompt for each row in the dataset.
+def format_text(row):
+    input_parts = ""
+    output_part = ""
+    for field in FIELDS:
+        if field != "audio":
+            part = f"{START_OF_SPECIAL_TOKENS[field]} {row[field]} {END_OF_SPECIAL_TOKENS[field]}"
+            input_parts += part + " "
+        else:
+            output_part = f"{START_OF_SPECIAL_TOKENS[field]} {' '.join(row['snac_tokens_list'])} {END_OF_SPECIAL_TOKENS[field]}"
+    text = f"{input_parts.strip()} {output_part} {EOS_TOKEN}"
+    eval_text = f"{input_parts.strip()} {START_OF_SPECIAL_TOKENS['audio']} "
+    row["text"] = text
+    row["eval_text"] = eval_text
+    return row
+
+
+train_dataset = train_dataset.map(format_text)
+eval_dataset = eval_dataset.map(format_text)
+logger.success("Formatted text for training and evaluation datasets.")
+
+# Set training arguments.
+training_args = SFTConfig(
+    num_train_epochs=2,
+    per_device_train_batch_size=PER_DEVICE_TRAIN_BATCH_SIZE,
+    gradient_accumulation_steps=GRADIENT_ACCUMULATION_STEPS,
+    optim="adamw_8bit",
+    learning_rate=5e-5 if FULL_FINETUNING else 2e-4,
+    lr_scheduler_type="cosine",
+    warmup_ratio=0.02,
+    do_eval=True,
+    eval_strategy="steps",
+    eval_steps=50,
+    logging_strategy="steps",
+    logging_steps=1,
+    save_strategy="steps",
+    save_only_model=True,
+    save_steps=1250,
+    output_dir="outputs",
+    report_to="wandb",
+    run_name=WANDB_RUN_NAME,
+    seed=SEED,
+)
+
+# Initialize the SFTTrainer.
+trainer = SFTTrainer(
+    model=model,
+    tokenizer=tokenizer,
+    train_dataset=train_dataset,
+    eval_dataset=eval_dataset,
+    dataset_text_field="text",
+    max_seq_length=MAX_SEQ_LENGTH,
+    dataset_num_proc=2,
+    packing=True,
+    args=training_args,
+)
+
+logger.success("Initialized SFTTrainer with the specified configuration.")
+
+# Start the training process.
+logger.info("Starting the training process...")
+
+run = wandb.init()
+
+if WANDB_RUN_ID:
+    logger.info(f"Resuming from Weights & Biases run ID: {WANDB_RUN_ID}")
+
+    artifact = run.use_artifact(
+        f"{WANDB_USERNAME}/{WANDB_PROJECT}/{WANDB_RUN_ID}", type="model"
+    )
+
+    artifact_dir = artifact.download()
+
+    trainer.train(resume_from_checkpoint=artifact_dir)
+else:
+    try:
+        logger.info("Attempting to resume training from the last checkpoint...")
+
+        trainer.train(resume_from_checkpoint=True)
+    except Exception as err:
+        trainer.train()
+
+# Finish the Weights & Biases run.
+wandb.finish()
+
+logger.success("Training completed successfully.")
+
+# ! Saving and loading model doesn't work.
+# # Save the model and tokenizer.
+# model.save_pretrained_merged(
+#     f"{HUGGINGFACE_USERNAME}/{MODEL_NAME}",
+#     tokenizer,
+#     save_method="merged_16bit",
+# )
+# logger.success("Saved the model and tokenizer locally.")
+
+# model.push_to_hub_merged(
+#     f"{HUGGINGFACE_USERNAME}/{MODEL_NAME}",
+#     tokenizer,
+#     save_method="merged_16bit",
+#     token=HUGGINGFACE_TOKEN,
+# )
+# logger.success("Pushed the model and tokenizer to the Hugging Face Hub.")
+
+# del trainer, model, tokenizer
+
+# # Inference with the trained model.
+# # Load the model and tokenizer.
+# model, tokenizer = FastLanguageModel.from_pretrained(
+#     model_name=f"{HUGGINGFACE_USERNAME}/{MODEL_NAME}",
+#     load_in_4bit=True,
+#     max_seq_length=MAX_SEQ_LENGTH,
+# )
+
+FastLanguageModel.for_inference(model)
+
+logger.success(f"Loaded model for inference: {HUGGINGFACE_USERNAME}/{MODEL_NAME}")
+
+# Load the SNAC model for audio decoding.
+snac_model = SNAC.from_pretrained("hubertsiuzdak/snac_24khz")
+logger.success("Loaded SNAC model for audio decoding.")
+
+
+# Function to generate audio from a dataset row.
+def generate_audio(
+    row, model, tokenizer, temperature=0.4, top_p=0.9, repetition_penalty=1.05
+):
+    prompt = row["eval_text"]
+    inputs = tokenizer(prompt, return_tensors="pt")
+    max_tokens = MAX_SEQ_LENGTH - inputs.input_ids.shape[1]
+    output = model.generate(
+        input_ids=inputs.input_ids.to("cuda"),
+        attention_mask=inputs.attention_mask.to("cuda"),
+        max_new_tokens=max_tokens,
+        temperature=temperature,
+        top_p=top_p,
+        repetition_penalty=repetition_penalty,
+    )
+    audio_ids = []
+    for id in output[0]:
+        if id >= snac_offset:
+            audio_ids.append(id.item())
+    clean_audio_ids = []
+    for i in range((len(audio_ids) + 1) // 7):
+        for j in range(7):
+            clean_audio_ids += [audio_ids[7 * i + j], 220]
+    audio_tokens = tokenizer.decode(clean_audio_ids).strip().split(" ")
+    codes = [[], [], []]
+    for i in range((len(audio_tokens) + 1) // 7):
+        frame = []
+        for j in range(7):
+            _, _, code = audio_tokens[7 * i + j].split("_")
+            code = int(code[:-2])
+            frame.append(code)
+        codes[0].append(frame[0])
+        codes[1].append(frame[1])
+        codes[2].append(frame[2])
+        codes[2].append(frame[3])
+        codes[1].append(frame[4])
+        codes[2].append(frame[5])
+        codes[2].append(frame[6])
+    codes = [
+        torch.tensor(codes[0]).unsqueeze(0),
+        torch.tensor(codes[1]).unsqueeze(0),
+        torch.tensor(codes[2]).unsqueeze(0),
+    ]
+    try:
+        audio = snac_model.decode(codes)
+    except Exception as e:
+        logger.error(f"Error decoding audio: {e}")
+        return None
+    return audio.detach().squeeze().to("cpu").numpy()
+
+
+# Generate and save some examples.
+train_sample = generate_audio(train_dataset[0], model, tokenizer)
+if train_sample is None:
+    logger.error("Failed to generate audio for training sample.")
+else:
+    sf.write("train.wav", train_sample, 24000)
+    logger.success("Generated and saved training sample audio.")
+
+eval_sample = generate_audio(eval_dataset[0], model, tokenizer)
+if eval_sample is None:
+    logger.error("Failed to generate audio for evaluation sample.")
+else:
+    sf.write("eval.wav", eval_sample, 24000)
+    logger.success("Generated and saved evaluation sample audio.")

.source_train_orpheus.py

@@ -0,0 +1,412 @@
+# * Install unsloth, PEFT, Weights & Biases, SNAC, pandas, soundfile and loguru.
+# !pip install unsloth peft==0.15.2 wandb snac pandas soundfile loguru
+
+# Import necessary libraries.
+# * unsloth import should always be at the top.
+from unsloth import FastLanguageModel
+
+import os
+
+from datasets import load_dataset
+from huggingface_hub import login
+from loguru import logger
+from snac import SNAC
+from trl import SFTConfig, SFTTrainer
+import soundfile as sf
+import torch
+import wandb
+
+
+# Set up constants and configurations.
+STAGE = 1
+HUGGINGFACE_USERNAME = ""  # ! Fill.
+
+if STAGE == 1:
+    # * You need to request access to the model at https://huggingface.co/canopylabs/3b-hi-pretrain-research_release.
+    BASE_MODEL = "canopylabs/3b-hi-pretrain-research_release"
+    TARGET_MODULES = [
+        "q_proj",
+        "k_proj",
+        "v_proj",
+        "o_proj",
+        "up_proj",
+        "down_proj",
+        "gate_proj",
+        "lm_head",
+        "embed_tokens",
+    ]
+    TRAIN_CSV_PATH = "data/data_stage_1.csv"
+    VALID_CSV_PATH = "data/data_eval.csv"
+    LR = 2e-4
+    EPOCHS = 2
+    MODEL_NAME = f"snorTTS-indicv0-stage-{STAGE}"
+else:
+    BASE_MODEL = f"{HUGGINGFACE_USERNAME}/snorTTS-indicv0-stage-1"
+    TARGET_MODULES = [
+        "q_proj",
+        "k_proj",
+        "v_proj",
+        "o_proj",
+        "up_proj",
+        "down_proj",
+        "gate_proj",
+    ]
+    TRAIN_CSV_PATH = "data/data_stage_2.csv"
+    VALID_CSV_PATH = "data/data_eval.csv"
+    LR = 2e-4
+    EPOCHS = 2
+    MODEL_NAME = f"snorTTS-indicv0-stage-{STAGE}"
+
+TRAIN_NUM_SAMPLES = None
+EVAL_NUM_SAMPLES = 250
+MAX_SEQ_LENGTH = 2048
+PER_DEVICE_TRAIN_BATCH_SIZE = 8
+GRADIENT_ACCUMULATION_STEPS = 4
+WANDB_USERNAME = ""  # ! Fill.
+WANDB_PROJECT = MODEL_NAME
+WANDB_LOG_MODEL = "checkpoint"
+WANDB_RUN_NAME = f"{MODEL_NAME}-training"
+WANDB_RUN_ID = None
+SEED = 3407
+HUGGINGFACE_TOKEN = ""  # ! Fill.
+WANDB_TOKEN = ""  # ! Fill.
+
+# * Use the following command to start the training: python train_orpheus.py
+
+# Login to Hugging Face.
+login(token=HUGGINGFACE_TOKEN)
+
+# Login to Weights & Biases.
+wandb.login(key=WANDB_TOKEN)
+
+# Set up environment variables for Weights & Biases.
+os.environ["WANDB_PROJECT"] = WANDB_PROJECT
+os.environ["WANDB_LOG_MODEL"] = WANDB_LOG_MODEL
+
+# Load the model and tokenizer.
+model, tokenizer = FastLanguageModel.from_pretrained(
+    model_name=BASE_MODEL,
+    load_in_4bit=True,
+    max_seq_length=MAX_SEQ_LENGTH,
+    token=HUGGINGFACE_TOKEN,
+)
+logger.success(f"Loaded model: {BASE_MODEL}")
+
+# Load the special tokens for the tokenizer.
+tokeniser_length = 128256
+
+start_of_text_id = 128000
+end_of_text_id = 128009
+start_of_speech_id = tokeniser_length + 1
+end_of_speech_id = tokeniser_length + 2
+start_of_human_id = tokeniser_length + 3
+end_of_human_id = tokeniser_length + 4
+start_of_ai_id = tokeniser_length + 5
+end_of_ai_id = tokeniser_length + 6
+pad_token_id = tokeniser_length + 7
+audio_start_id = tokeniser_length + 10
+
+start_of_text_token = tokenizer.decode([start_of_text_id])
+end_of_text_token = tokenizer.decode([end_of_text_id])
+start_of_speech_token = tokenizer.decode([start_of_speech_id])
+end_of_speech_token = tokenizer.decode([end_of_speech_id])
+start_of_human_token = tokenizer.decode([start_of_human_id])
+end_of_human_token = tokenizer.decode([end_of_human_id])
+start_of_ai_token = tokenizer.decode([start_of_ai_id])
+end_of_ai_token = tokenizer.decode([end_of_ai_id])
+pad_token = tokenizer.decode([pad_token_id])
+audio_start_token = tokenizer.decode([audio_start_id])
+
+logger.success("Load special tokens for the tokenizer.")
+
+# Set the padding token and padding side.
+tokenizer.pad_token = pad_token
+tokenizer.padding_side = "left"
+logger.success("Set padding token and padding side for the tokenizer.")
+
+# Get parameter efficient fine-tuning model.
+model = FastLanguageModel.get_peft_model(
+    model,
+    r=192,
+    target_modules=TARGET_MODULES,
+    lora_alpha=384,
+    random_state=SEED,
+)
+logger.success("Initialized parameter efficient fine-tuning model.")
+
+# Load training and validation datasets.
+# The dataset should be in CSV format with columns user (str), language (str), utterance (str), and snac_codes (list of lists).
+train_dataset = load_dataset("csv", data_files=TRAIN_CSV_PATH)["train"]
+eval_dataset = load_dataset("csv", data_files=VALID_CSV_PATH)["train"]
+
+if TRAIN_NUM_SAMPLES:
+    train_dataset = train_dataset.shuffle(seed=SEED).select(
+        range(min(TRAIN_NUM_SAMPLES, len(train_dataset)))
+    )
+
+if EVAL_NUM_SAMPLES:
+    eval_dataset = eval_dataset.shuffle(seed=SEED).select(
+        range(min(EVAL_NUM_SAMPLES, len(eval_dataset)))
+    )
+
+logger.success(
+    f"Loaded datasets: {len(train_dataset)} training samples, {len(eval_dataset)} evaluation samples."
+)
+
+
+# Flatten and get SNAC token IDs from the audio codes.
+def flatten_and_get_audio_input_ids(row):
+    audio_codes = row["snac_codes"]
+    if isinstance(audio_codes, str):
+        audio_codes = eval(audio_codes)
+    snac_token_ids = []
+    for i in range(len(audio_codes[0])):
+        snac_token_ids.append(audio_codes[0][i] + 128266)
+        snac_token_ids.append(audio_codes[1][2 * i] + 128266 + 4096)
+        snac_token_ids.append(audio_codes[2][4 * i] + 128266 + (2 * 4096))
+        snac_token_ids.append(audio_codes[2][(4 * i) + 1] + 128266 + (3 * 4096))
+        snac_token_ids.append(audio_codes[1][(2 * i) + 1] + 128266 + (4 * 4096))
+        snac_token_ids.append(audio_codes[2][(4 * i) + 2] + 128266 + (5 * 4096))
+        snac_token_ids.append(audio_codes[2][(4 * i) + 3] + 128266 + (6 * 4096))
+    row["snac_token_ids"] = snac_token_ids
+    return row
+
+
+train_dataset = train_dataset.map(flatten_and_get_audio_input_ids)
+eval_dataset = eval_dataset.map(flatten_and_get_audio_input_ids)
+logger.success("Flattened and extracted SNAC token IDs from audio codes.")
+
+# Filter out rows with empty or None audio codes.
+train_dataset = train_dataset.filter(
+    lambda x: x["snac_token_ids"] is not None and len(x["snac_token_ids"]) > 0
+)
+eval_dataset = eval_dataset.filter(
+    lambda x: x["snac_token_ids"] is not None and len(x["snac_token_ids"]) > 0
+)
+logger.success("Filtered datasets to remove rows with empty or None audio codes.")
+
+
+# Remove duplicate frames from the audio codes.
+def remove_duplicate_frames(row):
+    vals = row["snac_token_ids"]
+    if len(vals) % 7 != 0:
+        raise ValueError("Input list length must be divisible by 7")
+    result = vals[:7]
+    for i in range(7, len(vals), 7):
+        current_first = vals[i]
+        previous_first = result[-7]
+        if current_first != previous_first:
+            result.extend(vals[i : i + 7])
+    row["snac_token_ids"] = result
+    return row
+
+
+train_dataset = train_dataset.map(remove_duplicate_frames)
+eval_dataset = eval_dataset.map(remove_duplicate_frames)
+logger.success("Removed duplicate frames from audio codes.")
+
+
+# Define a function to format the prompt for each row in the dataset.
+def format_text(row):
+    text = (
+        f"{start_of_human_token}{start_of_text_token}{row['language']}{row['user']}: {row['utterance']}{end_of_text_token}"
+        f"{end_of_human_token}{start_of_ai_token}{start_of_speech_token}"
+        f"{tokenizer.decode(row['snac_token_ids'])}{end_of_speech_token}{end_of_ai_token}"
+    )
+    eval_text_user = (
+        f"{start_of_human_token}{start_of_text_token}{row['language']}{row['user']}: {row['utterance']}{end_of_text_token}"
+        f"{end_of_human_token}{start_of_ai_token}{start_of_speech_token}"
+    )
+    eval_text_no_user = (
+        f"{start_of_human_token}{start_of_text_token}{row['utterance']}{end_of_text_token}"
+        f"{end_of_human_token}{start_of_ai_token}{start_of_speech_token}"
+    )
+    row["text"] = text
+    row["eval_text_user"] = eval_text_user
+    row["eval_text_no_user"] = eval_text_no_user
+    return row
+
+
+train_dataset = train_dataset.map(format_text)
+eval_dataset = eval_dataset.map(format_text)
+logger.success("Formatted text for training and evaluation datasets.")
+
+
+# Tokenize the text in the datasets without adding special tokens.
+def tokenize_function(example):
+    return tokenizer(
+        example["text"],
+        add_special_tokens=False,
+        truncation=True,
+        max_length=MAX_SEQ_LENGTH,
+    )
+
+
+train_dataset = train_dataset.map(tokenize_function)
+eval_dataset = eval_dataset.map(tokenize_function)
+logger.success("Tokenized text in the datasets without adding special tokens.")
+
+# Set training arguments.
+training_args = SFTConfig(
+    num_train_epochs=EPOCHS,
+    per_device_train_batch_size=PER_DEVICE_TRAIN_BATCH_SIZE,
+    gradient_accumulation_steps=GRADIENT_ACCUMULATION_STEPS,
+    optim="adamw_8bit",
+    learning_rate=LR,
+    lr_scheduler_type="cosine",
+    warmup_ratio=0.02,
+    do_eval=True,
+    eval_strategy="steps",
+    eval_steps=50,
+    logging_strategy="steps",
+    logging_steps=1,
+    save_strategy="steps",
+    save_only_model=True,
+    save_steps=1250,
+    output_dir="outputs",
+    report_to="wandb",
+    run_name=WANDB_RUN_NAME,
+    seed=SEED,
+)
+
+# Initialize the SFTTrainer.
+trainer = SFTTrainer(
+    model=model,
+    tokenizer=tokenizer,
+    train_dataset=train_dataset,
+    eval_dataset=eval_dataset,
+    max_seq_length=MAX_SEQ_LENGTH,
+    dataset_num_proc=2,
+    packing=True,
+    args=training_args,
+)
+
+logger.success("Initialized SFTTrainer with the specified configuration.")
+
+# Start the training process.
+logger.info("Starting the training process...")
+
+run = wandb.init()
+
+if WANDB_RUN_ID:
+    logger.info(f"Resuming from Weights & Biases run ID: {WANDB_RUN_ID}")
+
+    artifact = run.use_artifact(
+        f"{WANDB_USERNAME}/{WANDB_PROJECT}/{WANDB_RUN_ID}", type="model"
+    )
+
+    artifact_dir = artifact.download()
+
+    trainer.train(resume_from_checkpoint=artifact_dir)
+else:
+    try:
+        logger.info("Attempting to resume training from the last checkpoint...")
+
+        trainer.train(resume_from_checkpoint=True)
+    except Exception as err:
+        trainer.train()
+
+# Finish the Weights & Biases run.
+wandb.finish()
+
+logger.success("Training completed successfully.")
+
+# Inference with the trained model.
+FastLanguageModel.for_inference(model)
+logger.success(f"Model {MODEL_NAME} is ready for inference.")
+
+# Load the SNAC model for audio decoding.
+snac_model = SNAC.from_pretrained("hubertsiuzdak/snac_24khz")
+logger.success("Loaded SNAC model for audio decoding.")
+
+
+# Function to generate audio from a dataset row.
+def generate_audio(
+    row,
+    model,
+    tokenizer,
+    user=False,
+    temperature=0.4,
+    top_p=0.9,
+    repetition_penalty=1.05,
+):
+    try:
+        if user:
+            prompt = row["eval_text_user"]
+        else:
+            prompt = row["eval_text_no_user"]
+        inputs = tokenizer(prompt, add_special_tokens=False, return_tensors="pt")
+        max_tokens = MAX_SEQ_LENGTH - inputs.input_ids.shape[1]
+        output = model.generate(
+            input_ids=inputs.input_ids.to("cuda"),
+            attention_mask=inputs.attention_mask.to("cuda"),
+            max_new_tokens=max_tokens,
+            temperature=temperature,
+            top_p=top_p,
+            repetition_penalty=repetition_penalty,
+            eos_token_id=end_of_speech_id,
+        )
+        audio_ids = []
+        for id in output[0]:
+            if id >= audio_start_id:
+                audio_ids.append(id.item())
+        clean_audio_ids = []
+        for i in range((len(audio_ids) + 1) // 7):
+            for j in range(7):
+                clean_audio_ids += [audio_ids[7 * i + j] - audio_start_id]
+        codes = [[], [], []]
+        for i in range((len(clean_audio_ids) + 1) // 7):
+            codes[0].append(clean_audio_ids[7 * i])
+            codes[1].append(clean_audio_ids[7 * i + 1] - 4096)
+            codes[2].append(clean_audio_ids[7 * i + 2] - (2 * 4096))
+            codes[2].append(clean_audio_ids[7 * i + 3] - (3 * 4096))
+            codes[1].append(clean_audio_ids[7 * i + 4] - (4 * 4096))
+            codes[2].append(clean_audio_ids[7 * i + 5] - (5 * 4096))
+            codes[2].append(clean_audio_ids[7 * i + 6] - (6 * 4096))
+        codes = [
+            torch.tensor(codes[0]).unsqueeze(0),
+            torch.tensor(codes[1]).unsqueeze(0),
+            torch.tensor(codes[2]).unsqueeze(0),
+        ]
+        audio = snac_model.decode(codes)
+        return audio.detach().squeeze().to("cpu").numpy()
+    except Exception as e:
+        logger.error(f"Error decoding audio: {e}")
+        return None
+
+
+# Generate and save some examples.
+train_sample = generate_audio(train_dataset[0], model, tokenizer, True)
+if train_sample is None:
+    logger.error("Failed to generate audio for training sample.")
+else:
+    sf.write(f"train_{STAGE}.wav", train_sample, 24000)
+    logger.success("Generated and saved training sample audio.")
+
+
+dir_ = f"eval_{STAGE}/"
+os.makedirs(dir_, exist_ok=True)
+for i in range(10):
+    eval_sample = generate_audio(eval_dataset[i], model, tokenizer, True)
+    if eval_sample is None:
+        logger.error(f"Failed to generate audio for evaluation sample {i}.")
+    else:
+        filename = dir_ + f"eval_{i}.wav"
+        sf.write(filename, eval_sample, 24000)
+        logger.success(f"Generated and saved evaluation sample audio as {filename}.")
+
+# Save the model and tokenizer.
+model.save_pretrained_merged(
+    f"{HUGGINGFACE_USERNAME}/{MODEL_NAME}",
+    tokenizer,
+    save_method="merged_16bit",
+)
+logger.success("Saved the model and tokenizer locally.")
+
+model.push_to_hub_merged(
+    f"{HUGGINGFACE_USERNAME}/{MODEL_NAME}",
+    tokenizer,
+    save_method="merged_16bit",
+    token=HUGGINGFACE_TOKEN,
+)
+logger.success("Pushed the model and tokenizer to the Hugging Face Hub.")

Dockerfile

@@ -0,0 +1,31 @@
+FROM pytorch/pytorch:2.5.1-cuda12.1-cudnn9-runtime
+
+ENV DEBIAN_FRONTEND=noninteractive
+ENV PYTHONDONTWRITEBYTECODE=1
+ENV PYTHONUNBUFFERED=1
+ENV PIP_DISABLE_PIP_VERSION_CHECK=1
+ENV PIP_DEFAULT_TIMEOUT=180
+
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    ffmpeg \
+    sox \
+    libsox-dev \
+    libsndfile1 \
+    && rm -rf /var/lib/apt/lists/*
+
+WORKDIR /app
+COPY requirements.txt /app/requirements.txt
+RUN bash -lc 'set -e; \
+    for i in 1 2 3 4 5; do \
+        echo "pip install attempt $i/5"; \
+        pip install --no-cache-dir --retries 25 --timeout 240 --prefer-binary -r /app/requirements.txt && exit 0; \
+        echo "pip install failed, retrying in 15s..."; \
+        sleep 15; \
+    done; \
+    echo "pip install failed after 5 attempts"; \
+    exit 1'
+
+COPY app /app/app
+EXPOSE 8000
+
+CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8000"]

README.md

@@ -0,0 +1,248 @@
+# snorTTS Hosting Pipeline (RunPod + Load Testing)
+
+This folder contains a complete starter pipeline for hosting your TTS model with a simple API and testing parallel load.
+
+## 1) What users get
+
+- A single HTTP endpoint: `POST /v1/tts`
+- Inputs: `utterance`, `language`, `user_id`
+- Defaults are server-side tuned.
+- Optional options endpoint for dropdowns: `GET /v1/options`
+
+## 2) API Contract
+
+### POST /v1/tts
+
+Request body:
+
+```json
+{
+  "utterance": "नमस्ते, आप कैसे हैं?",
+  "language": "hindi",
+  "user_id": "159"
+}
+```
+
+Response modes:
+
+- `response_mode=wav` (default): returns `audio/wav`
+- `response_mode=json`: returns base64 audio and metadata
+
+Example:
+
+```bash
+curl -X POST "http://localhost:8000/v1/tts?response_mode=wav" \
+  -H "Content-Type: application/json" \
+  -d '{"utterance":"नमस्ते, आप कैसे हैं?","language":"hindi","user_id":"159"}' \
+  --output out.wav
+```
+
+### GET /v1/options
+
+Returns dropdown-compatible language/speaker map and defaults.
+
+### GET /health
+
+Simple liveness check.
+
+### GET /ready
+
+True once model and decoder are loaded.
+
+## 3) Local run (before RunPod)
+
+1. Copy env:
+
+```bash
+cp .env.example .env
+```
+
+2. Set `HF_TOKEN` in `.env`.
+
+3. Build image:
+
+```bash
+docker build -t snortts-api:latest .
+```
+
+4. Run container:
+
+```bash
+docker run --gpus all --env-file .env -p 8000:8000 snortts-api:latest
+```
+
+Optional (only if you want denoise enabled in production image):
+
+```bash
+# Add these to requirements and rebuild only if needed
+pip install librosa==0.11.0 deepfilternet==0.5.6
+```
+
+5. Smoke test:
+
+```bash
+curl http://localhost:8000/ready
+```
+
+## 4) RunPod deployment steps
+
+1. Push image to Docker Hub or GHCR.
+2. Create RunPod GPU Pod.
+3. Set container image to your pushed tag.
+4. Expose port `8000`.
+5. Add env vars from `.env.example` in RunPod UI.
+6. Wait for startup, then test `/ready`.
+7. Test `/v1/tts`.
+
+## 4B) RunPod without Docker (recommended if image build is flaky)
+
+You can deploy directly on a standard RunPod PyTorch pod without building an image.
+
+1. Create a GPU Pod from a PyTorch template (CUDA 12.1 compatible).
+2. Expose port `8000`.
+3. In Pod terminal, clone or upload this `tts_hosting` folder under `/workspace/tts_hosting`.
+4. Create `.env` (copy from `.env.example`) and set at least `HF_TOKEN`.
+5. Run setup once:
+
+```bash
+cd /workspace/tts_hosting
+bash scripts/runpod_setup.sh
+```
+
+Note: setup installs `torch` and `torchaudio` from the CUDA 12.8 index for better compatibility with newer GPUs (including RTX 5090-class pods).
+
+6. Start API server:
+
+```bash
+cd /workspace/tts_hosting
+bash scripts/runpod_start.sh
+```
+
+7. Check readiness from your local machine:
+
+```bash
+curl http://<runpod-public-ip-or-url>:8000/ready
+```
+
+8. Test generation:
+
+```bash
+curl -X POST "http://<runpod-public-ip-or-url>:8000/v1/tts?response_mode=wav" \
+  -H "Content-Type: application/json" \
+  -d '{"utterance":"नमस्ते, आप कैसे हैं?","language":"hindi","user_id":"159"}' \
+  --output out.wav
+```
+
+Tip: if the pod restarts often, keep code and venv under `/workspace` so it persists.
+
+## 5) Load testing with Locust
+
+From this directory:
+
+```bash
+pip install -r loadtest/requirements.txt
+```
+
+Then run:
+
+```bash
+locust -f loadtest/locustfile.py --host http://<your-runpod-url>
+```
+
+Or headless:
+
+```bash
+locust -f loadtest/locustfile.py --host http://<your-runpod-url> \
+  --users 10 --spawn-rate 2 --run-time 5m --headless
+```
+
+## 6) Suggested test plan
+
+- Step 1: users 1, 2, 4, 8, 12
+- Step 2: record p50, p95, p99 latency
+- Step 3: record failure rate and GPU memory usage
+- Step 4: choose safe `MAX_INFLIGHT_REQUESTS`
+
+## 7) Key files
+
+- `app/main.py`: FastAPI endpoints
+- `app/runtime.py`: model load and synthesis runtime
+- `app/speaker_map.py`: language -> speaker IDs + default speed
+- `loadtest/locustfile.py`: parallel load test script
+- `Dockerfile`: deployable image for RunPod
+
+## 8) Persistence checklist (before stopping pod)
+
+Use this quick checklist before stopping or recreating your pod:
+
+1. Confirm critical artifacts are pushed to Hugging Face:
+  - model repos
+  - adapter checkpoints
+  - sample audio datasets (if needed)
+2. Confirm runtime config is saved in project files:
+  - `.env`
+  - `app/speaker_map.py`
+3. Keep project under `/workspace/tts_hosting` (network volume).
+4. Do not rely on root filesystem paths outside `/workspace` for anything critical.
+
+What usually persists:
+- `/workspace/*`
+- remote artifacts (Hugging Face, Git)
+
+What may not persist across image/pod recreation:
+- global apt installs
+- global pip installs
+- temporary files under root filesystem
+
+## 9) Fast recovery setup (if some data is lost)
+
+If your environment is partially reset but `/workspace/tts_hosting` still exists:
+
+1. Reinstall runtime deps and venv:
+
+```bash
+cd /workspace/tts_hosting
+bash scripts/runpod_setup.sh
+```
+
+2. Restore `.env` values (especially `HF_TOKEN` and `MODEL_NAME`).
+
+3. Start service:
+
+```bash
+cd /workspace/tts_hosting
+bash scripts/runpod_start.sh
+```
+
+4. Verify locally:
+
+```bash
+curl http://127.0.0.1:8000/health
+curl http://127.0.0.1:8000/ready
+curl http://127.0.0.1:8000/v1/options
+```
+
+5. Verify public URL (if HTTP port 8000 is exposed):
+
+```bash
+curl https://<pod-id>-8000.proxy.runpod.net/health
+```
+
+6. Smoke-test synthesis:
+
+```bash
+curl -X POST "http://127.0.0.1:8000/v1/tts?response_mode=wav" \
+  -H "Content-Type: application/json" \
+  -d '{"utterance":"नमस्ते, आप कैसे हैं?","language":"hindi","user_id":"159"}' \
+  --output out.wav
+```
+
+## 10) Optional backup command
+
+Create a lightweight backup archive (without virtualenv and cache):
+
+```bash
+cd /workspace
+tar --exclude='.git' --exclude='.venv-tts' --exclude='__pycache__' \
+   -czf tts_hosting_backup_$(date +%F_%H%M).tar.gz tts_hosting
+```

README_EXPLAINER.md

@@ -0,0 +1,188 @@
+# README_EXPLAINER
+
+Purpose: give strong project context to humans and Copilot agents running on a RunPod pod.
+
+## Project summary
+
+This project hosts an Indic multilingual TTS model behind an HTTP API, with a small input surface for end users:
+- utterance
+- language
+- user_id
+
+The service applies tuned inference defaults server-side and returns generated audio.
+
+## Source model and pipeline context
+
+Base model details:
+- Model lineage is based on `snorbyte/snorTTS-Indic-v0`
+- Hosted checkpoint currently used by this project: `Mevearth2/Quantized-Merged-TTS`
+- Architecture family: LLaMA-style causal LM generating audio tokens
+- Audio decode backend: SNAC (`hubertsiuzdak/snac_24khz`)
+
+High-level generation flow:
+1. Build prompt with language + speaker id + utterance
+2. Generate SNAC token ids with the LM
+3. Convert token stream into SNAC codebooks
+4. Decode to 24 kHz waveform
+5. Apply optional post-process (speed, denoise)
+
+Prompt format used:
+`<custom_token_3><|begin_of_text|>{language}{user_id}: {utterance}<|eot_id|><custom_token_4><custom_token_5><custom_token_1>`
+
+## Data context (important for future finetuning)
+
+Training dataset reference:
+- HF dataset: `snorbyte/indic-tts-sample-snac-encoded`
+
+Observed splits:
+- `stage_1`
+- `stage_2`
+- `eval`
+
+Common columns in all splits:
+- utterance
+- language
+- emotion
+- type
+- act
+- rating
+- gender
+- age
+- environment
+- user
+- snac_codes
+- stage
+
+Language set:
+- hindi
+- tamil
+- telugu
+- marathi
+- kannada
+- malayalam
+- punjabi
+- gujarati
+- bengali
+
+Note for retraining work:
+- The hosted dataset split names are not `train/valid/test`; scripts should use `stage_1`, `stage_2`, `eval` explicitly.
+
+## Speaker mapping context
+
+This project includes language-speaker validation and recommended speed defaults in `app/speaker_map.py`.
+
+Current practical mapping by language:
+- hindi: 159, 49, 43
+- tamil: 188, 128, 176
+- bengali: 125
+- malayalam: 189, 124
+- kannada: 142, 138, 131, 59
+- telugu: 69, 133
+- punjabi: 191, 67, 201
+- gujarati: 62, 190
+- marathi: 205, 82, 199, 203
+
+## What has already been implemented
+
+Production starter API:
+- `app/main.py`
+  - `POST /v1/tts` (inputs: utterance, language, user_id)
+  - `GET /v1/options` (dropdown data for UI)
+  - `GET /health`
+  - `GET /ready`
+
+Inference runtime:
+- `app/runtime.py`
+  - one-time model load
+  - runtime defaults for generation
+  - prompt construction
+  - token-to-audio decode
+  - wav bytes response
+
+Schemas:
+- `app/schemas.py`
+
+Speaker map and validation:
+- `app/speaker_map.py`
+
+Load test starter:
+- `loadtest/locustfile.py`
+- `loadtest/requirements.txt`
+
+RunPod no-docker scripts:
+- `scripts/runpod_setup.sh`
+- `scripts/runpod_start.sh`
+
+## Important environment variables
+
+Main:
+- `MODEL_NAME` (default `Mevearth2/Quantized-Merged-TTS`)
+- `HF_TOKEN`
+
+Service behavior:
+- `MAX_INFLIGHT_REQUESTS`
+- `TTS_TEMPERATURE`
+- `TTS_TOP_P`
+- `TTS_REPETITION_PENALTY`
+- `TTS_MAX_SEQ_LENGTH`
+- `TTS_MAX_WORDS`
+- `TTS_DENOISE`
+
+Template file:
+- `.env.example` (no secrets)
+Actual runtime secrets:
+- `.env` (do not commit)
+
+## Why no-docker path exists
+
+Docker image builds were unstable due to slow network/timeouts while downloading large Python wheels in some environments.
+
+Current recommended fast path:
+1. Open RunPod PyTorch pod
+2. Clone `tts_hosting` into `/workspace/tts_hosting`
+3. Run `scripts/runpod_setup.sh`
+4. Run `scripts/runpod_start.sh`
+
+## Current known constraints
+
+- Generation can be slow for long utterances, so word limits are enforced.
+- Denoise dependencies are intentionally optional to reduce deployment friction.
+- 5090 GPUs require newer PyTorch builds; verify pod torch compatibility first.
+
+## What to do next (execution plan)
+
+Phase 1: Stabilize endpoint
+1. Deploy via no-docker RunPod path
+2. Verify `/ready` and sample `/v1/tts` calls
+3. Confirm language-user validation behavior
+
+Phase 2: Frontend readiness
+1. Use `/v1/options` for language and speaker dropdowns
+2. Keep only 3 user inputs in UI
+3. Keep generation knobs hidden on backend defaults
+
+Phase 3: Load testing
+1. Run Locust against pod URL
+2. Sweep concurrency: 1, 2, 4, 8, 12
+3. Track p50/p95/p99 latency and error rate
+4. Set stable `MAX_INFLIGHT_REQUESTS`
+
+Phase 4: Production hardening
+1. Add API authentication
+2. Add structured logs and metrics
+3. Add queue/backpressure policy and request timeout policy
+4. Add autoscaling strategy and cost-per-request reporting
+
+## For Copilot agents on pod
+
+When helping on this repo, prioritize:
+1. Reliability over feature creep
+2. Keeping API input surface simple
+3. Preserving speaker/language validation
+4. Avoiding dependency bloat unless requested
+5. Not committing secrets from `.env`
+
+If modifying runtime behavior, always keep:
+- prompt format compatibility
+- speaker mapping checks
+- deterministic server defaults unless explicitly changed

app/main.py

@@ -0,0 +1,99 @@
+import asyncio
+import base64
+import os
+import uuid
+from contextlib import asynccontextmanager
+from pathlib import Path
+
+from fastapi import FastAPI, HTTPException
+from fastapi.responses import FileResponse, Response
+from loguru import logger
+
+from app.runtime import TTSRuntime, SAMPLE_RATE
+from app.schemas import HealthResponse, OptionsResponse, ReadyResponse, TTSJSONResponse, TTSRequest
+from app.speaker_map import SUPPORTED_SPEAKERS, validate_language_user
+
+MAX_INFLIGHT = int(os.getenv("MAX_INFLIGHT_REQUESTS", "2"))
+runtime = TTSRuntime()
+semaphore = asyncio.Semaphore(MAX_INFLIGHT)
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    runtime.load()
+    yield
+
+
+app = FastAPI(title="snorTTS Hosting API", version="1.0.0", lifespan=lifespan)
+
+
+@app.get("/")
+def root() -> dict:
+    return {
+        "service": "snorTTS Hosting API",
+        "routes": ["/health", "/ready", "/v1/options", "/v1/tts", "/ui"],
+    }
+
+
+@app.get("/ui")
+def ui() -> FileResponse:
+    return FileResponse(Path(__file__).with_name("ui.html"))
+
+
+@app.get("/health", response_model=HealthResponse)
+def health() -> HealthResponse:
+    return HealthResponse()
+
+
+@app.get("/ready", response_model=ReadyResponse)
+def ready() -> ReadyResponse:
+    return ReadyResponse(ready=runtime.is_ready)
+
+
+@app.get("/v1/options", response_model=OptionsResponse)
+def options() -> OptionsResponse:
+    defaults = {
+        "temperature": float(os.getenv("TTS_TEMPERATURE", "0.4")),
+        "top_p": float(os.getenv("TTS_TOP_P", "0.9")),
+        "repetition_penalty": float(os.getenv("TTS_REPETITION_PENALTY", "1.05")),
+    }
+    return OptionsResponse(speakers=SUPPORTED_SPEAKERS, defaults=defaults)
+
+
+@app.post("/v1/tts", response_class=Response)
+async def tts(req: TTSRequest, response_mode: str = "wav"):
+    if not validate_language_user(req.language, req.user_id):
+        raise HTTPException(
+            status_code=400,
+            detail=f"Invalid user_id '{req.user_id}' for language '{req.language}'",
+        )
+
+    async with semaphore:
+        try:
+            wav_bytes, duration_ms = await asyncio.to_thread(
+                runtime.synthesize_wav_bytes,
+                req.utterance,
+                req.language,
+                req.user_id,
+            )
+        except RuntimeError as exc:
+            raise HTTPException(status_code=422, detail=str(exc)) from exc
+        except Exception as exc:
+            logger.exception("TTS inference failed")
+            raise HTTPException(status_code=500, detail=f"Inference failed: {exc}") from exc
+
+    request_id = str(uuid.uuid4())
+    if response_mode == "json":
+        payload = TTSJSONResponse(
+            request_id=request_id,
+            sample_rate=SAMPLE_RATE,
+            duration_ms=duration_ms,
+            audio_base64=base64.b64encode(wav_bytes).decode("ascii"),
+        )
+        return payload
+
+    headers = {
+        "X-Request-Id": request_id,
+        "X-Duration-Ms": str(duration_ms),
+    }
+    return Response(content=wav_bytes, media_type="audio/wav", headers=headers)

app/runtime.py

@@ -0,0 +1,241 @@
+import io
+import os
+import threading
+import time
+from typing import Optional
+
+import numpy as np
+import soundfile as sf
+import torch
+import torchaudio
+from huggingface_hub import login as hf_login
+from loguru import logger
+from snac import SNAC
+from transformers import AutoModelForCausalLM, AutoTokenizer
+
+from app.speaker_map import recommended_speed
+
+
+TOKENISER_LENGTH = 128256
+END_OF_SPEECH_ID = TOKENISER_LENGTH + 2
+PAD_TOKEN_ID = TOKENISER_LENGTH + 7
+AUDIO_START_ID = TOKENISER_LENGTH + 10
+SAMPLE_RATE = 24000
+
+DEFAULTS = {
+    "temperature": float(os.getenv("TTS_TEMPERATURE", "0.4")),
+    "top_p": float(os.getenv("TTS_TOP_P", "0.9")),
+    "repetition_penalty": float(os.getenv("TTS_REPETITION_PENALTY", "1.05")),
+    "max_seq_length": int(os.getenv("TTS_MAX_SEQ_LENGTH", "2048")),
+    "max_words": int(os.getenv("TTS_MAX_WORDS", "50")),
+    "denoise": os.getenv("TTS_DENOISE", "false").lower() == "true",
+}
+
+
+class TTSRuntime:
+    def __init__(self) -> None:
+        self._model = None
+        self._tokenizer = None
+        self._snac = None
+        self._df_model = None
+        self._df_state = None
+        self._device = "cuda" if torch.cuda.is_available() else "cpu"
+        self._loaded = False
+        self._lock = threading.Lock()
+
+    @property
+    def is_ready(self) -> bool:
+        return self._loaded
+
+    @staticmethod
+    def _resolve_hf_token(cli_token: Optional[str]) -> Optional[str]:
+        if cli_token:
+            return cli_token
+        return (
+            os.getenv("HF_TOKEN")
+            or os.getenv("HUGGINGFACE_TOKEN")
+            or os.getenv("HUGGING_FACE_HUB_TOKEN")
+        )
+
+    def load(self, model_name: Optional[str] = None, hf_token: Optional[str] = None) -> None:
+        with self._lock:
+            if self._loaded:
+                return
+
+            # Some environments set HF fast transfer globally without
+            # installing hf_transfer, which breaks all downloads.
+            os.environ["HF_HUB_ENABLE_HF_TRANSFER"] = "0"
+
+            model_name = model_name or os.getenv("MODEL_NAME", "Mevearth2/Quantized-Merged-TTS")
+            token = self._resolve_hf_token(hf_token)
+
+            if token:
+                try:
+                    hf_login(token=token, add_to_git_credential=False)
+                    logger.info("HF auth success")
+                except Exception as exc:
+                    logger.warning(f"HF login warning: {exc}")
+
+            logger.info(f"Loading tokenizer/model from {model_name}")
+            self._tokenizer = AutoTokenizer.from_pretrained(model_name, token=token)
+            self._model = AutoModelForCausalLM.from_pretrained(
+                model_name,
+                token=token,
+                torch_dtype=torch.float16 if self._device == "cuda" else torch.float32,
+            )
+            self._model.to(self._device)
+            self._model.eval()
+
+            pad_token = self._tokenizer.decode([PAD_TOKEN_ID])
+            self._tokenizer.pad_token = pad_token
+            self._tokenizer.padding_side = "left"
+
+            try:
+                from unsloth import FastLanguageModel
+
+                FastLanguageModel.for_inference(self._model)
+                logger.info("Unsloth inference enabled")
+            except Exception:
+                logger.info("Unsloth not enabled")
+
+            logger.info("Loading SNAC decoder")
+            self._snac = SNAC.from_pretrained("hubertsiuzdak/snac_24khz")
+
+            if DEFAULTS["denoise"]:
+                try:
+                    from df.enhance import init_df
+
+                    self._df_model, self._df_state, _ = init_df()
+                    logger.info("DeepFilter initialized")
+                except Exception as exc:
+                    logger.warning(f"DeepFilter unavailable: {exc}")
+
+            self._loaded = True
+
+    @staticmethod
+    def _build_prompt(utterance: str, language: str, user_id: str) -> str:
+        return (
+            "<custom_token_3><|begin_of_text|>"
+            f"{language}{user_id}: {utterance}"
+            "<|eot_id|><custom_token_4><custom_token_5><custom_token_1>"
+        )
+
+    @staticmethod
+    def _extract_audio_ids(output_ids: torch.Tensor) -> list[int]:
+        raw_audio_ids = [tok.item() for tok in output_ids if tok.item() >= AUDIO_START_ID]
+        clean = []
+        full_groups = len(raw_audio_ids) // 7
+        for i in range(full_groups):
+            base = i * 7
+            for j in range(7):
+                clean.append(raw_audio_ids[base + j] - AUDIO_START_ID)
+        return clean
+
+    @staticmethod
+    def _snac_tokens_to_codebooks(clean_audio_ids: list[int]):
+        codes = [[], [], []]
+        full_groups = len(clean_audio_ids) // 7
+
+        for i in range(full_groups):
+            b = i * 7
+            codes[0].append(clean_audio_ids[b + 0])
+            codes[1].append(clean_audio_ids[b + 1] - 4096)
+            codes[2].append(clean_audio_ids[b + 2] - (2 * 4096))
+            codes[2].append(clean_audio_ids[b + 3] - (3 * 4096))
+            codes[1].append(clean_audio_ids[b + 4] - (4 * 4096))
+            codes[2].append(clean_audio_ids[b + 5] - (5 * 4096))
+            codes[2].append(clean_audio_ids[b + 6] - (6 * 4096))
+
+        if len(codes[0]) == 0 or len(codes[1]) == 0 or len(codes[2]) == 0:
+            return None
+
+        return [
+            torch.tensor(codes[0]).unsqueeze(0),
+            torch.tensor(codes[1]).unsqueeze(0),
+            torch.tensor(codes[2]).unsqueeze(0),
+        ]
+
+    @staticmethod
+    def _apply_speed(audio: np.ndarray, speed: float) -> np.ndarray:
+        if abs(speed - 1.0) <= 1e-4:
+            return audio
+        # Prefer Sox tempo when available; some runtime builds omit sox_effects.
+        if hasattr(torchaudio, "sox_effects") and hasattr(torchaudio.sox_effects, "apply_effects_tensor"):
+            audio_t = torch.from_numpy(audio).unsqueeze(0)
+            out_t, _ = torchaudio.sox_effects.apply_effects_tensor(
+                audio_t,
+                SAMPLE_RATE,
+                effects=[["tempo", f"{speed}"]],
+            )
+            return out_t.squeeze(0).cpu().numpy()
+
+        # Fallback: lightweight time-stretch via interpolation.
+        # This keeps service functional even without Sox bindings.
+        in_len = int(audio.shape[0])
+        out_len = max(1, int(round(in_len / speed)))
+        x_old = np.linspace(0.0, 1.0, num=in_len, dtype=np.float64)
+        x_new = np.linspace(0.0, 1.0, num=out_len, dtype=np.float64)
+        stretched = np.interp(x_new, x_old, audio.astype(np.float64))
+        return stretched.astype(np.float32)
+
+    def _apply_denoise(self, audio: np.ndarray) -> np.ndarray:
+        if self._df_model is None or self._df_state is None:
+            return audio
+        try:
+            import librosa
+            from df.enhance import enhance
+
+            audio_48k = librosa.resample(audio, orig_sr=SAMPLE_RATE, target_sr=48000)
+            audio_48k_t = torch.from_numpy(audio_48k).unsqueeze(0)
+            denoised = enhance(self._df_model, self._df_state, audio_48k_t)
+            denoised_np = denoised.squeeze(0).cpu().numpy()
+            return librosa.resample(denoised_np, orig_sr=48000, target_sr=SAMPLE_RATE)
+        except Exception as exc:
+            logger.warning(f"Denoise failed: {exc}")
+            return audio
+
+    def synthesize_wav_bytes(self, utterance: str, language: str, user_id: str) -> tuple[bytes, int]:
+        if not self._loaded:
+            raise RuntimeError("Runtime is not loaded")
+
+        start = time.perf_counter()
+        safe_utterance = " ".join(utterance.split()[: DEFAULTS["max_words"]])
+        prompt = self._build_prompt(safe_utterance, language, user_id)
+        inputs = self._tokenizer(prompt, add_special_tokens=False, return_tensors="pt")
+
+        input_ids = inputs.input_ids.to(self._device)
+        attention_mask = inputs.attention_mask.to(self._device)
+        max_new_tokens = max(32, DEFAULTS["max_seq_length"] - input_ids.shape[1])
+
+        with torch.inference_mode():
+            output = self._model.generate(
+                input_ids=input_ids,
+                attention_mask=attention_mask,
+                max_new_tokens=max_new_tokens,
+                do_sample=True,
+                temperature=DEFAULTS["temperature"],
+                top_p=DEFAULTS["top_p"],
+                repetition_penalty=DEFAULTS["repetition_penalty"],
+                eos_token_id=END_OF_SPEECH_ID,
+            )
+
+        clean_audio_ids = self._extract_audio_ids(output[0])
+        if not clean_audio_ids:
+            raise RuntimeError("No audio token IDs generated")
+
+        codes = self._snac_tokens_to_codebooks(clean_audio_ids)
+        if codes is None:
+            raise RuntimeError("Insufficient audio token IDs for SNAC decode")
+
+        with torch.inference_mode():
+            audio = self._snac.decode(codes)
+
+        audio_np = audio.detach().squeeze().cpu().numpy().astype(np.float32)
+        audio_np = self._apply_speed(audio_np, recommended_speed(language, str(user_id)))
+        audio_np = self._apply_denoise(audio_np)
+
+        wav_buf = io.BytesIO()
+        sf.write(wav_buf, audio_np, SAMPLE_RATE, format="WAV")
+        wav_bytes = wav_buf.getvalue()
+        duration_ms = int((time.perf_counter() - start) * 1000)
+        return wav_bytes, duration_ms

app/schemas.py

@@ -0,0 +1,40 @@
+from typing import Literal, Optional
+
+from pydantic import BaseModel, Field
+
+
+class TTSRequest(BaseModel):
+    utterance: str = Field(min_length=1, max_length=500)
+    language: Literal[
+        "hindi",
+        "tamil",
+        "telugu",
+        "marathi",
+        "kannada",
+        "malayalam",
+        "punjabi",
+        "gujarati",
+        "bengali",
+    ]
+    user_id: str = Field(min_length=1, max_length=8)
+
+
+class TTSJSONResponse(BaseModel):
+    request_id: str
+    sample_rate: int
+    duration_ms: int
+    audio_base64: str
+    output_format: Literal["wav_base64"] = "wav_base64"
+
+
+class HealthResponse(BaseModel):
+    status: Literal["ok"] = "ok"
+
+
+class ReadyResponse(BaseModel):
+    ready: bool
+
+
+class OptionsResponse(BaseModel):
+    speakers: dict
+    defaults: dict

app/speaker_map.py

@@ -0,0 +1,56 @@
+SUPPORTED_SPEAKERS = {
+    "hindi": {
+        "159": {"speed": 1.05},
+        "49": {"speed": 1.10},
+        "43": {"speed": 1.10},
+    },
+    "tamil": {
+        "188": {"speed": 1.10},
+        "128": {"speed": 1.15},
+        "176": {"speed": 1.10},
+    },
+    "bengali": {
+        "125": {"speed": 1.10},
+    },
+    "malayalam": {
+        "189": {"speed": 1.10},
+        "124": {"speed": 1.10},
+    },
+    "kannada": {
+        "142": {"speed": 1.05},
+        "138": {"speed": 1.10},
+        "131": {"speed": 1.10},
+        "59": {"speed": 1.10},
+    },
+    "telugu": {
+        "69": {"speed": 1.10},
+        "133": {"speed": 1.10},
+    },
+    "punjabi": {
+        "191": {"speed": 1.08},
+        "67": {"speed": 1.06},
+        "201": {"speed": 1.10},
+    },
+    "gujarati": {
+        "62": {"speed": 1.15},
+        "190": {"speed": 1.25},
+    },
+    "marathi": {
+        "205": {"speed": 1.05},
+        "82": {"speed": 1.05},
+        "199": {"speed": 1.10},
+        "203": {"speed": 1.15},
+    },
+}
+
+
+def validate_language_user(language: str, user_id: str) -> bool:
+    if language not in SUPPORTED_SPEAKERS:
+        return False
+    return str(user_id) in SUPPORTED_SPEAKERS[language]
+
+
+def recommended_speed(language: str, user_id: str, default: float = 1.05) -> float:
+    if not validate_language_user(language, str(user_id)):
+        return default
+    return float(SUPPORTED_SPEAKERS[language][str(user_id)]["speed"])

app/ui.html

@@ -0,0 +1,206 @@
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <title>snorTTS UI</title>
+  <style>
+    :root {
+      --bg: #0f172a;
+      --panel: #111827;
+      --text: #e5e7eb;
+      --muted: #9ca3af;
+      --accent: #22c55e;
+      --accent-2: #06b6d4;
+      --danger: #ef4444;
+    }
+    * { box-sizing: border-box; }
+    body {
+      margin: 0;
+      font-family: "IBM Plex Sans", "Segoe UI", sans-serif;
+      color: var(--text);
+      background: radial-gradient(1000px 500px at 10% 0%, #1f2937, var(--bg));
+      min-height: 100vh;
+      padding: 24px;
+    }
+    .card {
+      max-width: 920px;
+      margin: 0 auto;
+      background: linear-gradient(180deg, #0b1220, var(--panel));
+      border: 1px solid #1f2937;
+      border-radius: 16px;
+      padding: 20px;
+      box-shadow: 0 20px 60px rgba(0, 0, 0, 0.35);
+    }
+    h1 { margin: 0 0 4px; font-size: 1.6rem; }
+    p { margin: 0 0 16px; color: var(--muted); }
+    .grid {
+      display: grid;
+      grid-template-columns: 1fr 1fr;
+      gap: 12px;
+    }
+    .full { grid-column: 1 / -1; }
+    label { display: block; font-size: 0.9rem; margin-bottom: 6px; color: #cbd5e1; }
+    select, textarea, button {
+      width: 100%;
+      border-radius: 10px;
+      border: 1px solid #334155;
+      background: #0b1020;
+      color: var(--text);
+      padding: 10px 12px;
+      font-size: 0.95rem;
+    }
+    textarea { min-height: 110px; resize: vertical; }
+    .actions {
+      display: flex;
+      gap: 10px;
+      margin-top: 12px;
+    }
+    button {
+      cursor: pointer;
+      font-weight: 600;
+      background: linear-gradient(90deg, var(--accent), var(--accent-2));
+      color: #001018;
+      border: 0;
+    }
+    button.secondary {
+      background: #1f2937;
+      color: #cbd5e1;
+      border: 1px solid #334155;
+    }
+    .status { margin-top: 10px; font-size: 0.92rem; color: var(--muted); }
+    .error { color: var(--danger); }
+    .ok { color: #4ade80; }
+    audio { width: 100%; margin-top: 14px; }
+    code { color: #7dd3fc; }
+    @media (max-width: 760px) {
+      .grid { grid-template-columns: 1fr; }
+    }
+  </style>
+</head>
+<body>
+  <div class="card">
+    <h1>Synth TTS endpoint</h1>
+    <p>Generates audio from <code>/v1/tts</code> using server-side defaults.</p>
+
+    <div class="grid">
+      <div>
+        <label for="language">Language</label>
+        <select id="language"></select>
+      </div>
+      <div>
+        <label for="user_id">User ID</label>
+        <select id="user_id"></select>
+      </div>
+      <div class="full">
+        <label for="utterance">Utterance</label>
+        <textarea id="utterance" placeholder="Type text to synthesize...">नमस्ते, आज आप कैसे हैं?</textarea>
+      </div>
+    </div>
+
+    <div class="actions">
+      <button id="generate">Generate Audio</button>
+      <button class="secondary" id="copyCurl">Copy cURL</button>
+    </div>
+
+    <div id="status" class="status"></div>
+    <audio id="player" controls></audio>
+  </div>
+
+  <script>
+    const state = { speakers: {} };
+    const $ = (id) => document.getElementById(id);
+
+    async function loadOptions() {
+      const res = await fetch('/v1/options');
+      if (!res.ok) throw new Error('Failed to load options');
+      const data = await res.json();
+      state.speakers = data.speakers || {};
+      const langSel = $('language');
+      langSel.innerHTML = '';
+      Object.keys(state.speakers).forEach((lang) => {
+        const opt = document.createElement('option');
+        opt.value = lang;
+        opt.textContent = lang;
+        langSel.appendChild(opt);
+      });
+      updateUsers();
+      langSel.addEventListener('change', updateUsers);
+    }
+
+    function updateUsers() {
+      const lang = $('language').value;
+      const users = Object.keys(state.speakers[lang] || {});
+      const userSel = $('user_id');
+      userSel.innerHTML = '';
+      users.forEach((u) => {
+        const opt = document.createElement('option');
+        opt.value = u;
+        opt.textContent = u;
+        userSel.appendChild(opt);
+      });
+    }
+
+    function setStatus(text, cls = '') {
+      const el = $('status');
+      el.className = `status ${cls}`.trim();
+      el.textContent = text;
+    }
+
+    async function generate() {
+      const payload = {
+        utterance: $('utterance').value.trim(),
+        language: $('language').value,
+        user_id: $('user_id').value,
+      };
+      if (!payload.utterance) {
+        setStatus('Utterance is required.', 'error');
+        return;
+      }
+
+      setStatus('Generating...');
+      $('generate').disabled = true;
+
+      try {
+        const res = await fetch('/v1/tts?response_mode=wav', {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify(payload),
+        });
+
+        if (!res.ok) {
+          const txt = await res.text();
+          throw new Error(`${res.status} ${txt}`);
+        }
+
+        const blob = await res.blob();
+        const url = URL.createObjectURL(blob);
+        const player = $('player');
+        player.src = url;
+        await player.play().catch(() => {});
+        setStatus('Audio generated successfully.', 'ok');
+      } catch (err) {
+        setStatus(`Failed: ${err.message}`, 'error');
+      } finally {
+        $('generate').disabled = false;
+      }
+    }
+
+    function copyCurl() {
+      const payload = {
+        utterance: $('utterance').value.trim(),
+        language: $('language').value,
+        user_id: $('user_id').value,
+      };
+      const cmd = `curl -X POST 'http://127.0.0.1:8000/v1/tts?response_mode=wav' -H 'Content-Type: application/json' -d '${JSON.stringify(payload)}' --output tts.wav`;
+      navigator.clipboard.writeText(cmd)
+        .then(() => setStatus('cURL copied to clipboard.', 'ok'))
+        .catch(() => setStatus('Could not copy cURL.', 'error'));
+    }
+
+    $('generate').addEventListener('click', generate);
+    $('copyCurl').addEventListener('click', copyCurl);
+    loadOptions().catch((e) => setStatus(e.message, 'error'));
+  </script>
+</body>
+</html>

loadtest/locustfile.py

@@ -0,0 +1,57 @@
+import json
+import os
+import random
+
+from locust import HttpUser, between, task
+
+
+LANGUAGE_SPEAKER = {
+    "hindi": ["159", "49", "43"],
+    "tamil": ["188", "128", "176"],
+    "bengali": ["125"],
+    "malayalam": ["189", "124"],
+    "kannada": ["142", "138", "131", "59"],
+    "telugu": ["69", "133"],
+    "punjabi": ["191", "67", "201"],
+    "gujarati": ["62", "190"],
+    "marathi": ["205", "82", "199", "203"],
+}
+
+SAMPLE_TEXT = {
+    "hindi": "नमस्ते, आज आप कैसे हैं?",
+    "tamil": "வணக்கம், இன்று எப்படி இருக்கீங்க?",
+    "bengali": "হ্যালো, আজ তুমি কেমন আছো?",
+    "malayalam": "നമസ്കാരം, ഇന്ന് എങ്ങനെയുണ്ട്?",
+    "kannada": "ನಮಸ್ಕಾರ, ಇಂದು ಹೇಗಿದ್ದೀರಿ?",
+    "telugu": "నమస్కారం, ఈరోజు ఎలా ఉన్నారు?",
+    "punjabi": "ਸਤ ਸ੍ਰੀ ਅਕਾਲ, ਅੱਜ ਤੁਸੀਂ ਕਿਵੇਂ ਹੋ?",
+    "gujarati": "નમસ્તે, આજે તમે કેમ છો?",
+    "marathi": "नमस्कार, आज तुम्ही कसे आहात?",
+}
+
+
+class TTSUser(HttpUser):
+    wait_time = between(0.2, 1.0)
+    host = os.getenv("LOCUST_HOST", "http://localhost:8000")
+
+    @task
+    def generate_tts(self):
+        language = random.choice(list(LANGUAGE_SPEAKER.keys()))
+        payload = {
+            "utterance": SAMPLE_TEXT[language],
+            "language": language,
+            "user_id": random.choice(LANGUAGE_SPEAKER[language]),
+        }
+        with self.client.post(
+            "/v1/tts?response_mode=wav",
+            data=json.dumps(payload),
+            headers={"Content-Type": "application/json"},
+            catch_response=True,
+            timeout=180,
+        ) as response:
+            if response.status_code != 200:
+                response.failure(f"status={response.status_code} body={response.text[:200]}")
+            elif not response.content:
+                response.failure("empty audio response")
+            else:
+                response.success()

loadtest/requirements.txt

@@ -0,0 +1 @@
+locust==2.37.2

requirements.txt

@@ -0,0 +1,9 @@
+fastapi==0.115.12
+uvicorn[standard]==0.34.2
+pydantic==2.11.3
+numpy==1.26.4
+soundfile==0.13.1
+loguru==0.7.3
+huggingface_hub==0.31.1
+transformers==4.51.3
+snac==1.2.1

scripts/runpod_setup.sh

@@ -0,0 +1,44 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+ROOT_DIR="${ROOT_DIR:-/workspace/tts_hosting}"
+VENV_PATH="${VENV_PATH:-/workspace/.venv-tts}"
+PYTHON_BIN="${PYTHON_BIN:-python3}"
+TORCH_INDEX_URL="${TORCH_INDEX_URL:-https://download.pytorch.org/whl/cu128}"
+
+if [[ ! -d "$ROOT_DIR" ]]; then
+  echo "ERROR: ROOT_DIR '$ROOT_DIR' does not exist."
+  echo "Clone/copy tts_hosting there first."
+  exit 1
+fi
+
+retry_pip_install() {
+  local install_target="$1"
+  for i in 1 2 3 4 5; do
+    echo "pip install attempt ${i}/5"
+    if pip install --retries 20 --timeout 240 --prefer-binary $install_target; then
+      return 0
+    fi
+    echo "pip install failed, retrying in 20s..."
+    sleep 20
+  done
+  echo "pip install failed after 5 attempts"
+  return 1
+}
+
+sudo apt-get update
+sudo apt-get install -y --no-install-recommends ffmpeg sox libsox-dev libsndfile1
+
+$PYTHON_BIN -m venv "$VENV_PATH"
+source "$VENV_PATH/bin/activate"
+
+pip install --upgrade pip setuptools wheel
+
+# Explicit torch install for modern RunPod GPUs (including RTX 5090).
+retry_pip_install "--index-url $TORCH_INDEX_URL torch torchaudio"
+
+# Install the remaining app dependencies.
+retry_pip_install "-r $ROOT_DIR/requirements.txt"
+
+echo "Setup complete."
+echo "Activate with: source $VENV_PATH/bin/activate"

scripts/runpod_start.sh

@@ -0,0 +1,32 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+ROOT_DIR="${ROOT_DIR:-/workspace/tts_hosting}"
+VENV_PATH="${VENV_PATH:-/workspace/.venv-tts}"
+PORT="${PORT:-8000}"
+
+if [[ ! -d "$ROOT_DIR" ]]; then
+  echo "ERROR: ROOT_DIR '$ROOT_DIR' does not exist."
+  exit 1
+fi
+
+if [[ ! -f "$VENV_PATH/bin/activate" ]]; then
+  echo "ERROR: virtual env not found at '$VENV_PATH'."
+  echo "Run scripts/runpod_setup.sh first."
+  exit 1
+fi
+
+cd "$ROOT_DIR"
+source "$VENV_PATH/bin/activate"
+
+if [[ -f ".env" ]]; then
+  set -a
+  source .env
+  set +a
+fi
+
+# Some pod images set this globally but do not ship hf_transfer,
+# which breaks model downloads at startup.
+export HF_HUB_ENABLE_HF_TRANSFER="0"
+
+exec uvicorn app.main:app --host 0.0.0.0 --port "$PORT"