Duplicate from beleata74/Ani-Voice-API

Co-authored-by: none <beleata74@users.noreply.huggingface.co>

.gitattributes

@@ -0,0 +1,38 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text
+demo1_conversation.wav filter=lfs diff=lfs merge=lfs -text
+demo2_numbers.wav filter=lfs diff=lfs merge=lfs -text
+demo3_expressive.wav filter=lfs diff=lfs merge=lfs -text

BgTTS/.gitattributes

@@ -0,0 +1,53 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text
+samples/sample_female_bg1.wav filter=lfs diff=lfs merge=lfs -text
+samples/sample_female_bg2.wav filter=lfs diff=lfs merge=lfs -text
+samples/sample_female_bg3.wav filter=lfs diff=lfs merge=lfs -text
+samples/sample_female_en1.wav filter=lfs diff=lfs merge=lfs -text
+samples/sample_female_en2.wav filter=lfs diff=lfs merge=lfs -text
+samples/sample_female_en3.wav filter=lfs diff=lfs merge=lfs -text
+samples/sample_male2_bg1.wav filter=lfs diff=lfs merge=lfs -text
+samples/sample_male2_bg2.wav filter=lfs diff=lfs merge=lfs -text
+samples/sample_male2_bg3.wav filter=lfs diff=lfs merge=lfs -text
+samples/sample_male2_en1.wav filter=lfs diff=lfs merge=lfs -text
+samples/sample_male2_en2.wav filter=lfs diff=lfs merge=lfs -text
+samples/sample_male2_en3.wav filter=lfs diff=lfs merge=lfs -text
+samples/sample_male_bg1.wav filter=lfs diff=lfs merge=lfs -text
+samples/sample_male_bg2.wav filter=lfs diff=lfs merge=lfs -text
+samples/sample_male_bg3.wav filter=lfs diff=lfs merge=lfs -text
+samples/sample_male_en1.wav filter=lfs diff=lfs merge=lfs -text
+samples/sample_male_en2.wav filter=lfs diff=lfs merge=lfs -text
+samples/sample_male_en3.wav filter=lfs diff=lfs merge=lfs -text

BgTTS/README.md

@@ -0,0 +1,270 @@
+---
+license: apache-2.0
+language:
+  - bg
+  - en
+pipeline_tag: text-to-speech
+tags:
+  - tts
+  - bulgarian
+  - miocodec
+  - encoder-decoder
+  - voice-cloning
+  - speech-synthesis
+library_name: pytorch
+---
+
+# BgTTS-38M V2 — Bulgarian Text-to-Speech with Voice Cloning
+
+A lightweight **38M parameter** encoder-decoder TTS model for **Bulgarian and English** speech synthesis with **zero-shot voice cloning** via [MioCodec](https://huggingface.co/Aratako/MioCodec-25Hz-24kHz).
+
+**V2 improvements over V1:**
+- **Speaker normalization** — stable voice quality across all reference audio files
+- **Larger training dataset** — 1,537 hours (vs 1,172h in V1)
+- **BF16 training** — more stable gradients, no GradScaler needed
+- **Zero dropout** — better utilization of model capacity
+- **20 epochs** with careful LR scheduling
+
+## Audio Samples
+
+### Female Voice (Bulgarian)
+
+<audio controls src="https://huggingface.co/beleata74/BgTTS-38M-V2/resolve/main/samples/sample_female_bg1.wav"></audio>
+
+### Female Voice (English)
+
+<audio controls src="https://huggingface.co/beleata74/BgTTS-38M-V2/resolve/main/samples/sample_female_en1.wav"></audio>
+
+### Male Voice 1 (Bulgarian)
+
+<audio controls src="https://huggingface.co/beleata74/BgTTS-38M-V2/resolve/main/samples/sample_male_bg1.wav"></audio>
+
+### Male Voice 1 (English)
+
+<audio controls src="https://huggingface.co/beleata74/BgTTS-38M-V2/resolve/main/samples/sample_male_en1.wav"></audio>
+
+### Male Voice 2 (Bulgarian)
+
+<audio controls src="https://huggingface.co/beleata74/BgTTS-38M-V2/resolve/main/samples/sample_male2_bg1.wav"></audio>
+
+### Male Voice 2 (English)
+
+<audio controls src="https://huggingface.co/beleata74/BgTTS-38M-V2/resolve/main/samples/sample_male2_en1.wav"></audio>
+
+## Key Features
+
+- **Bilingual**: Native Bulgarian + English in a single model
+- **Voice cloning**: Zero-shot — just provide 3-10 seconds of reference audio
+- **Tiny footprint**: 146 MB inference checkpoint, runs on CPU
+- **Fast**: RTF ~0.3 on both GPU and CPU (3.3× faster than real-time)
+- **Speaker-stable**: V2's normalized speaker embedding ensures consistent quality regardless of reference audio
+
+## 🎙️ Voice Cloning
+
+This model supports zero-shot voice cloning — it can generate speech in any voice given just a short reference audio clip. No fine-tuning needed.
+
+### How it Works
+
+1. Provide a reference audio (3-10 seconds of clear speech, WAV format, ideally 24kHz)
+2. MioCodec extracts a 128-dimensional speaker embedding (`global_embedding`)
+3. The embedding is **L2-normalized** and scaled by a learned parameter (`spk_scale`) before being added to the decoder
+4. The same embedding is used for MioCodec waveform reconstruction
+
+### V2 Improvement: Speaker Normalization
+
+In V1, the speaker embedding had 7× larger norm than content tokens, causing the model to over-rely on the reference audio for pronunciation quality. V2 normalizes the speaker vector to unit norm, ensuring:
+- **Consistent quality** across all reference voices
+- The model learns speech patterns from data, not from speaker shortcuts
+- Reference audio only affects **timbre**, not articulation
+
+## Model Architecture
+
+| Component | Details |
+|---|---|
+| Text Encoder | 4-layer bidirectional Transformer (d=384, 6 heads, ff=1536) |
+| Audio Decoder | 8-layer causal Transformer (d=384, 6 heads, ff=1536) with cross-attention |
+| Speaker Injection | L2-normalized Linear(128 → 384) with learned scale, additive bias |
+| Audio Codec | [MioCodec](https://huggingface.co/Aratako/MioCodec-25Hz-24kHz) 25Hz, 1 codebook, 12800 codes, 24kHz output |
+| Total Parameters | 38.2M (Encoder: 9.6M, Decoder: 28.6M) |
+| Activations | SwiGLU |
+| Normalization | RMSNorm (pre-norm) |
+| Positional Encoding | Learned (encoder), RoPE (decoder) |
+| Embeddings | Tied decoder (lm_head = token_embedding) |
+| KV-Cache | Yes (for fast autoregressive inference) |
+
+### Tokenizer
+
+Character-level tokenizer supporting 146 characters:
+- Bulgarian Cyrillic (А-Я, а-я)
+- English Latin (A-Z, a-z)
+- Digits, punctuation, whitespace
+
+Total vocabulary: **12,955 tokens** (9 special + 146 text + 12,800 audio codes)
+
+## Training
+
+| Parameter | Value |
+|---|---|
+| **Data** | 728K samples, **1,537 hours** total |
+| Bulgarian | ~620K samples (~1,368 hours) |
+| English | ~108K samples (~169 hours) |
+| **Epochs** | 20 |
+| **LR Schedule** | Cosine decay, peak 7e-5, warmup 2 epochs, min 5e-6 |
+| **Batch Size** | 64 |
+| **Optimizer** | AdamW (betas=0.9, 0.999), weight decay 0.01 |
+| **Precision** | BF16 (no GradScaler) |
+| **Dropout** | 0.0 (unnecessary — model is 38M, data is 1,537h) |
+| **Final Loss** | 5.04 |
+| **Hardware** | NVIDIA RTX 5090 (32GB VRAM) |
+
+### Why Zero Dropout?
+
+With only 38M parameters and 138M audio tokens (1,537 hours), the model has **0.28 parameters per token**. Overfitting is mathematically impossible — the model is severely underfitting the data. Dropout only slows convergence without providing any regularization benefit.
+
+## Quick Start
+
+### Requirements
+
+```bash
+pip install torch torchaudio soundfile miocodec
+```
+
+### Python API
+
+```python
+import torch
+from model import load_for_inference
+from tokenizer import TTSTokenizer
+from codec import CodecV6
+from inference import generate
+
+device = "cuda"  # or "cpu"
+
+# Load model
+model = load_for_inference("checkpoint_inference.pt", device=device)
+tokenizer = TTSTokenizer()
+codec = CodecV6(device=device)
+
+# Get speaker embedding from reference audio
+ref = codec.encode("reference_speaker.wav")
+speaker_emb = ref["global_embedding"].to(device)
+
+# Generate
+codes = generate(
+    model, tokenizer,
+    text="Здравейте, как сте днес?",
+    speaker_emb=speaker_emb,
+    temperature=0.3,
+    top_k=250,
+    max_new_tokens=512,
+    device=device,
+)
+
+# Decode to audio
+if codes is not None:
+    wav = codec.tokens_to_wav(codes, speaker_emb, "output.wav")
+```
+
+### CLI
+
+```bash
+python inference.py \
+  --checkpoint checkpoint_inference.pt \
+  --text "Здравейте, как сте днес?" \
+  --speaker-wav reference.wav \
+  --output output.wav \
+  --temperature 0.3
+```
+
+### Web UI (Gradio)
+
+```bash
+python server.py
+# Opens at http://localhost:7860
+```
+
+### Parameters
+
+| Parameter | Default | Description |
+|---|---|---|
+| `--temperature` | 0.3 | Sampling temperature (lower = stable, higher = expressive) |
+| `--top-k` | 250 | Top-k filtering |
+| `--top-p` | 0.95 | Nucleus sampling threshold |
+| `--rep-penalty` | 1.1 | Repetition penalty on recent tokens |
+| `--max-tokens` | 512 | Maximum decoder steps (~20 seconds) |
+
+**Recommended temperature: 0.3** for clean, stable output. Use 0.5-0.7 for more expressive/varied speech.
+
+## ⚠️ Important: Sentence Length
+
+> The encoder supports up to **256 characters** (~18 seconds of audio). For longer texts, `inference.py` automatically splits by sentence boundaries and concatenates the audio. No manual splitting needed.
+
+## Files
+
+```
+checkpoint_inference.pt   # Model weights only (146 MB)
+checkpoint.pt             # Full checkpoint with optimizer state (438 MB, for continued training)
+config.py                 # Model configuration
+model.py                  # Architecture (TTSEncoderDecoder + speaker normalization)
+tokenizer.py              # Character-level tokenizer
+codec.py                  # MioCodec wrapper
+inference.py              # Inference pipeline with KV-cache + sentence splitting
+train.py                  # Training script (BF16)
+server.py                 # Gradio web UI
+samples/                  # Audio samples (3 voices × 2 languages × 3 texts)
+```
+
+## Performance
+
+### Benchmarks
+
+| Hardware | RTF | Speed | Notes |
+|---|---|---|---|
+| **Intel i3-9100F (CPU)** | **0.30** | **3.3× real-time** | **Windows 10, CPU-only, no GPU** |
+
+### CPU-only Deployment (Tested on Windows 10)
+
+| Component | Disk Space |
+|---|---|
+| Python venv (PyTorch CPU + deps) | 654 MB |
+| BgTTS-38M-V2 (checkpoint + code) | 146 MB |
+| MioCodec (auto-downloaded, cached) | 499 MB |
+| WavLM base+ (auto-downloaded, cached) | 872 MB |
+| **Total** | **2.12 GB** |
+
+No NVIDIA GPU, no CUDA, no special drivers needed. Works on any x86-64 machine with Python 3.8+.
+
+## Comparison with Other Models
+
+| Model | Parameters | Size | Languages | Voice Cloning | Open Source |
+|---|---|---|---|---|---|
+| **BgTTS-38M V2** | **38M** | **146 MB** | BG + EN | ✅ | ✅ |
+| Kokoro-82M | 82M | ~200 MB | Multi | ❌ | ✅ |
+| XTTS-v2 | ~467M | ~1.8 GB | 16 | ✅ | ✅ |
+| CSM-1B | 1B | ~4 GB | EN | ✅ | ✅ |
+| Dia-1.6B | 1.6B | ~6.4 GB | EN | ✅ | ✅ |
+
+BgTTS-38M V2 is the **smallest TTS model with voice cloning** we are aware of, and the **only** open-source TTS model with native Bulgarian language support.
+
+## Limitations
+
+- Best with sentences up to ~18 seconds. Longer texts are auto-split by `inference.py`.
+- Bulgarian quality is superior to English (82% of training data is Bulgarian).
+- Voice cloning quality depends on reference audio clarity — use clean recordings without background noise.
+- No explicit prosody control (pitch, speed) — these are implicitly learned from data.
+- Character-level tokenizer may struggle with rare Unicode characters outside the supported set.
+
+## License
+
+Apache 2.0
+
+## Citation
+
+```bibtex
+@misc{bgtts38mv2,
+  title={BgTTS-38M V2: Bulgarian Text-to-Speech with Voice Cloning and Speaker Normalization},
+  author={beleata74},
+  year={2026},
+  url={https://huggingface.co/beleata74/BgTTS-38M-V2}
+}
+```

BgTTS/__init__.py

@@ -0,0 +1 @@
+"""BG-TTS V6 — Encoder-Decoder with MioCodec + Speaker Embedding"""

BgTTS/checkpoint_inference.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b072815b1b915f2df60dc38d83bd9d524e9f67b76b64b91c36521dd59045a8ef
+size 152965750

BgTTS/codec.py

@@ -0,0 +1,124 @@
+"""
+V6 Codec — MioCodec 25Hz wrapper
+==================================
+Single codebook, 12800 codes, 25fps, 24kHz.
+Supports global_embedding for voice cloning.
+"""
+
+import torch
+import numpy as np
+import soundfile as sf
+from pathlib import Path
+from typing import Optional, Union
+
+from config import (
+    CODEC_MODEL_NAME, CODEC_SAMPLE_RATE,
+    CODEC_CODEBOOK_SIZE, CODEC_FRAME_RATE,
+)
+
+
+class CodecV6:
+    def __init__(self, device: str = "cuda"):
+        self.device = device
+        self.sample_rate = CODEC_SAMPLE_RATE  # 24000
+        self.codebook_size = CODEC_CODEBOOK_SIZE  # 12800
+        self.frame_rate = CODEC_FRAME_RATE  # 25.0
+        self._load_model()
+
+    def _load_model(self):
+        from miocodec import MioCodecModel
+        self.model = MioCodecModel.from_pretrained(CODEC_MODEL_NAME)
+        self.model = self.model.to(self.device).eval()
+        print(f"MioCodec loaded: {CODEC_MODEL_NAME}, {self.sample_rate}Hz, "
+              f"{self.frame_rate}fps, {self.codebook_size} codes")
+
+    @torch.no_grad()
+    def encode(self, wav_path: str | Path) -> dict:
+        """
+        Encode wav file → MioCodec codes + global_embedding.
+        """
+        data, sr = sf.read(str(wav_path), dtype='float32')
+        waveform = torch.from_numpy(data)
+        return self.encode_waveform(waveform, sr)
+
+    @torch.no_grad()
+    def encode_waveform(self, waveform: torch.Tensor, sr: int) -> dict:
+        """
+        Encode directly from waveform tensor.
+        waveform: [samples] or [channels, samples]
+        sr: int
+        """
+        if waveform.dim() == 2:  # stereo
+            waveform = waveform.mean(1)
+        if waveform.dim() == 1:
+            waveform = waveform.unsqueeze(0)  # [1, samples]
+            
+        if sr != self.sample_rate:
+            import torchaudio
+            waveform = torchaudio.functional.resample(waveform, sr, self.sample_rate)
+
+        audio = waveform.to(self.device).float()
+
+        # MioCodec encode returns (content_token_indices, global_embedding)
+        result = self.model.encode(audio)
+        codes = result.content_token_indices.squeeze().cpu()       # [num_frames]
+        global_emb = result.global_embedding.squeeze().cpu()       # [128]
+
+        return {
+            'codes': codes,
+            'global_embedding': global_emb,
+        }
+
+    @torch.no_grad()
+    def decode(self, codes: torch.Tensor,
+               global_embedding: torch.Tensor) -> torch.Tensor:
+        """
+        Decode MioCodec codes → waveform.
+
+        Args:
+            codes: [num_frames] — token indices in [0, 12799]
+            global_embedding: [128] — speaker embedding
+
+        Returns:
+            waveform: [samples] float32
+        """
+        codes = codes.to(self.device)
+        global_embedding = global_embedding.to(self.device)
+
+        # MioCodec expects flat tensors: codes [num_frames], emb [128]
+        if codes.dim() > 1:
+            codes = codes.squeeze()
+        if global_embedding.dim() > 1:
+            global_embedding = global_embedding.squeeze()
+
+        audio = self.model.decode(
+            global_embedding=global_embedding,
+            content_token_indices=codes,
+        )
+        return audio.squeeze().cpu().float()
+
+    def encode_to_tokens(self, wav_path: str) -> dict:
+        """Convenience: encode and return codes + embedding."""
+        return self.encode(wav_path)
+
+    def tokens_to_wav(self, codes: torch.Tensor,
+                      global_embedding: torch.Tensor,
+                      output: Optional[str] = None) -> torch.Tensor:
+        """Decode tokens to wav, optionally save."""
+        wav = self.decode(codes, global_embedding)
+        if output:
+            sf.write(output, wav.numpy(), self.sample_rate)
+        return wav
+
+    def get_stats(self, wav_path: str) -> dict:
+        """Get encoding stats for a wav file."""
+        result = self.encode(wav_path)
+        data, sr = sf.read(str(wav_path), dtype='float32')
+        dur = len(data) / sr if data.ndim == 1 else data.shape[0] / sr
+        n_tokens = len(result['codes'])
+        return {
+            "duration_sec": dur,
+            "num_tokens": n_tokens,
+            "tokens_per_sec": n_tokens / dur if dur > 0 else 0,
+            "global_emb_shape": tuple(result['global_embedding'].shape),
+        }

BgTTS/config.py

@@ -0,0 +1,142 @@
+"""
+V6 Config — Encoder-Decoder TTS with MioCodec + Speaker Embedding
+==================================================================
+Vocab layout:
+  [0..8]        = 9 special tokens
+  [9..154]      = ~146 text chars (BG + EN + digits + punct)
+  [155..12954]  = 12,800 audio tokens (MioCodec, 1 codebook)
+  Total = 12,955
+
+Architecture:
+  Encoder: 4L bidirectional, d=384, 6 heads — text understanding
+  Decoder: 8L causal + cross-attention, d=384, 6 heads — audio generation
+  Speaker: 128-dim global_embedding → Linear(128, 384) → added to decoder
+
+Key differences from V5:
+  - MioCodec (25fps, 1CB, 12800) instead of NanoCodec (12.5fps, 4CB, 16128)
+  - d=384 for both encoder and decoder (V5: enc=512, dec=768)
+  - 8 decoder layers (V5: 18)
+  - Speaker embedding injection (V5: discrete speaker tokens)
+  - max_text=256, max_audio=512 (V5: 512/2048)
+  - ~40M params (V5: 250M)
+  - Expected RTF ~0.15-0.25 (V5: 1.1)
+"""
+
+# ── MioCodec 25Hz ──────────────────────────────────────────────
+CODEC_MODEL_NAME     = "Aratako/MioCodec-25Hz-24kHz"
+CODEC_SAMPLE_RATE    = 24_000
+CODEC_NUM_CODEBOOKS  = 1
+CODEC_CODEBOOK_SIZE  = 12_800
+CODEC_FRAME_RATE     = 25.0
+CODEC_TOKENS_PER_SEC = 25  # 25fps × 1 codebook
+TOKENS_PER_FRAME     = 1
+SPEAKER_EMB_DIM      = 128  # MioCodec global_embedding dimension
+
+# ── Character set (same as V5) ─────────────────────────────────
+BG_LOWER  = "абвгдежзийклмнопрстуфхцчшщъьюя"
+BG_UPPER  = "АБВГДЕЖЗИЙКЛМНОПРСТУФХЦЧШЩЪЬЮЯ"
+EN_LOWER  = "abcdefghijklmnopqrstuvwxyz"
+EN_UPPER  = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+DIGITS    = "0123456789"
+PUNCT     = '.,!?;:-–—…"\'()[]{}«»„"" '
+EXTRA     = "\n\t"
+
+_ALL_CHARS: list[str] = []
+_seen: set[str] = set()
+for _src in [BG_LOWER, BG_UPPER, EN_LOWER, EN_UPPER, DIGITS, PUNCT, EXTRA]:
+    for _ch in _src:
+        if _ch not in _seen:
+            _ALL_CHARS.append(_ch)
+            _seen.add(_ch)
+
+# ── Special tokens (indices 0..8) ──────────────────────────────
+SPECIAL_TOKENS = {
+    "<pad>":             0,
+    "<start_of_text>":   1,
+    "<end_of_text>":     2,
+    "<start_of_speech>": 3,
+    "<end_of_speech>":   4,
+    "<spk_0>":           5,  # kept for compatibility, but speaker embedding is primary
+    "<spk_1>":           6,
+    "<spk_2>":           7,
+    "<spk_3>":           8,
+}
+NUM_SPECIAL_TOKENS = len(SPECIAL_TOKENS)     # 9
+
+# ── Vocab offsets ───────────────────────────────────────────────
+TEXT_CHARS       = _ALL_CHARS
+TEXT_VOCAB_SIZE  = len(TEXT_CHARS)             # ~146
+TEXT_OFFSET      = NUM_SPECIAL_TOKENS         # 9
+AUDIO_OFFSET     = TEXT_OFFSET + TEXT_VOCAB_SIZE  # 155
+NUM_AUDIO_TOKENS = CODEC_CODEBOOK_SIZE            # 12,800
+TOTAL_VOCAB_SIZE = AUDIO_OFFSET + NUM_AUDIO_TOKENS  # 12,955
+
+# Encoder needs only text vocab; decoder needs full vocab
+ENCODER_VOCAB_SIZE = AUDIO_OFFSET      # 155 (special + text)
+DECODER_VOCAB_SIZE = TOTAL_VOCAB_SIZE  # 12,955 (full)
+
+# ── Convenience IDs ─────────────────────────────────────────────
+PAD_TOKEN_ID             = SPECIAL_TOKENS["<pad>"]
+START_OF_TEXT_TOKEN_ID   = SPECIAL_TOKENS["<start_of_text>"]
+END_OF_TEXT_TOKEN_ID     = SPECIAL_TOKENS["<end_of_text>"]
+START_OF_SPEECH_TOKEN_ID = SPECIAL_TOKENS["<start_of_speech>"]
+END_OF_SPEECH_TOKEN_ID   = SPECIAL_TOKENS["<end_of_speech>"]
+SPK_0_TOKEN_ID           = SPECIAL_TOKENS["<spk_0>"]
+SPK_1_TOKEN_ID           = SPECIAL_TOKENS["<spk_1>"]
+
+# ── Helper functions ────────────────────────────────────────────
+def audio_token_id(code: int) -> int:
+    """MioCodec code → global token ID."""
+    return AUDIO_OFFSET + code
+
+def decode_audio_token(token_id: int) -> int:
+    """Global token ID → MioCodec code."""
+    return token_id - AUDIO_OFFSET
+
+def is_audio_token(token_id: int) -> bool:
+    return AUDIO_OFFSET <= token_id < AUDIO_OFFSET + NUM_AUDIO_TOKENS
+
+def is_special_token(token_id: int) -> bool:
+    return 0 <= token_id < NUM_SPECIAL_TOKENS
+
+def is_text_token(token_id: int) -> bool:
+    return TEXT_OFFSET <= token_id < AUDIO_OFFSET
+
+# ── V6 Model Config ────────────────────────────────────────────
+# Encoder: 4 bidirectional layers
+ENC_D_MODEL    = 384
+ENC_N_HEADS    = 6
+ENC_N_LAYERS   = 4
+ENC_D_FF       = 1536
+
+# Decoder: 8 causal layers with cross-attention
+DEC_D_MODEL    = 384
+DEC_N_HEADS    = 6
+DEC_N_LAYERS   = 8
+DEC_D_FF       = 1536
+
+MAX_TEXT_LEN   = 256         # Max text tokens (chars) — covers ~17s speech
+MAX_AUDIO_LEN  = 512         # Max audio tokens — 512/25 = 20.5s
+DROPOUT        = 0.0
+
+# ── Training defaults ──────────────────────────────────────────
+BATCH_SIZE     = 16          # Smaller model = bigger batch
+GRAD_ACCUM     = 4           # effective = 64
+LR             = 3e-4
+WEIGHT_DECAY   = 0.1
+WARMUP_STEPS   = 1000
+NUM_EPOCHS     = 5
+
+# ── Print summary ──────────────────────────────────────────────
+if __name__ == "__main__":
+    print(f"V6 Vocab Layout:")
+    print(f"  Special:  [0, {NUM_SPECIAL_TOKENS-1}]  ({NUM_SPECIAL_TOKENS} tokens)")
+    print(f"  Text:     [{TEXT_OFFSET}, {AUDIO_OFFSET-1}]  ({TEXT_VOCAB_SIZE} chars)")
+    print(f"  Audio:    [{AUDIO_OFFSET}, {TOTAL_VOCAB_SIZE-1}]  ({NUM_AUDIO_TOKENS} tokens)")
+    print(f"  TOTAL:    {TOTAL_VOCAB_SIZE}")
+    print()
+    print(f"V6 Encoder: d={ENC_D_MODEL}, heads={ENC_N_HEADS}, L={ENC_N_LAYERS}, ff={ENC_D_FF}")
+    print(f"V6 Decoder: d={DEC_D_MODEL}, heads={DEC_N_HEADS}, L={DEC_N_LAYERS}, ff={DEC_D_FF}")
+    print(f"V6 Codec:   MioCodec {CODEC_FRAME_RATE}fps, {CODEC_NUM_CODEBOOKS}CB × {CODEC_CODEBOOK_SIZE}")
+    print(f"V6 Speaker: {SPEAKER_EMB_DIM}-dim global_embedding")
+    print(f"V6 Limits:  max_text={MAX_TEXT_LEN}, max_audio={MAX_AUDIO_LEN}")

BgTTS/inference.py

@@ -0,0 +1,241 @@
+"""
+V6 Inference — encoder-decoder TTS with MioCodec + speaker cloning
+===================================================================
+1. Encode text with encoder (bidirectional, once)
+2. Autoregressively decode audio tokens with decoder + speaker embedding
+3. Decode tokens with MioCodec using global_embedding
+"""
+
+import torch
+import argparse
+import time
+from pathlib import Path
+from config import (
+    AUDIO_OFFSET, NUM_AUDIO_TOKENS, END_OF_SPEECH_TOKEN_ID,
+    START_OF_SPEECH_TOKEN_ID, CODEC_SAMPLE_RATE, CODEC_FRAME_RATE,
+)
+from tokenizer import TTSTokenizer
+from codec import CodecV6
+from model import load_for_inference
+
+
+def _split_text(text, tokenizer, max_len=250):
+    """Split text into chunks that fit within encoder max_text_len."""
+    import re
+    sentences = re.split(r'(?<=[.!?;:,])\s+', text)
+    chunks = []
+    current = ""
+    for sent in sentences:
+        candidate = (current + " " + sent).strip() if current else sent
+        enc_len = len(tokenizer.build_encoder_input(candidate))
+        if enc_len <= max_len:
+            current = candidate
+        else:
+            if current:
+                chunks.append(current)
+            # If single sentence is too long, split by words
+            if len(tokenizer.build_encoder_input(sent)) > max_len:
+                words = sent.split()
+                current = ""
+                for w in words:
+                    cand = (current + " " + w).strip() if current else w
+                    if len(tokenizer.build_encoder_input(cand)) <= max_len:
+                        current = cand
+                    else:
+                        if current:
+                            chunks.append(current)
+                        current = w
+            else:
+                current = sent
+    if current:
+        chunks.append(current)
+    return chunks
+
+
+@torch.no_grad()
+def generate(model, tokenizer, text, speaker_emb,
+             max_new_tokens=512, temperature=0.7, top_k=250,
+             top_p=0.95, rep_penalty=1.1, device="cuda"):
+    """
+    Generate audio tokens from text.
+
+    Args:
+        model: TTSEncoderDecoder
+        tokenizer: TTSTokenizer
+        text: input text string
+        speaker_emb: [128] MioCodec global_embedding
+        max_new_tokens: max decoder steps
+        temperature: sampling temperature
+        top_k: top-k filtering
+        top_p: nucleus sampling threshold
+        rep_penalty: repetition penalty on recent tokens
+        device: cuda/cpu
+
+    Returns:
+        torch.Tensor of MioCodec codes [num_frames], or None
+    """
+    # 1. Encode text (one shot, bidirectional)
+    enc_ids = tokenizer.build_encoder_input(text).unsqueeze(0).to(device)
+    enc_mask = torch.ones_like(enc_ids)
+
+    enc_out = model.encode(enc_ids, enc_mask)  # [1, T_enc, d_model]
+
+    # 2. Prepare speaker embedding
+    spk = speaker_emb.unsqueeze(0).to(device)  # [1, 128]
+
+    # 3. Start decoder with <sos>
+    dec_ids = torch.tensor([[START_OF_SPEECH_TOKEN_ID]], device=device)
+    past = None
+    generated_tokens = []
+
+    for step in range(max_new_tokens):
+        inp = dec_ids[:, -1:] if past is not None else dec_ids
+
+        # Only pass speaker_emb on first step (already baked into embeddings)
+        # Actually, with KV-cache, we only process new tokens, so speaker
+        # needs to be added each time. The model handles this correctly.
+        dec_out = model.decoder(
+            input_ids=inp,
+            encoder_output=enc_out,
+            encoder_mask=enc_mask,
+            speaker_emb=spk,
+            past_key_values=past,
+            use_cache=True,
+        )
+        past = dec_out["past_key_values"]
+        logits = dec_out["logits"][:, -1, :]
+
+        # Mask: only allow audio tokens + end_of_speech
+        mask = torch.full_like(logits, float("-inf"))
+        mask[:, AUDIO_OFFSET:AUDIO_OFFSET + NUM_AUDIO_TOKENS] = 0
+        mask[:, END_OF_SPEECH_TOKEN_ID] = 0
+        logits = logits + mask
+
+        # Repetition penalty on recent tokens
+        if rep_penalty != 1.0 and generated_tokens:
+            recent = set(generated_tokens[-100:])
+            for tid in recent:
+                if AUDIO_OFFSET <= tid < AUDIO_OFFSET + NUM_AUDIO_TOKENS:
+                    logits[:, tid] /= rep_penalty
+
+        logits = logits / temperature
+
+        # Top-k
+        if top_k > 0:
+            kth = torch.topk(logits, min(top_k, logits.shape[-1])).values[:, -1:]
+            logits[logits < kth] = float("-inf")
+
+        # Top-p (nucleus)
+        if top_p < 1.0:
+            sorted_l, sorted_i = torch.sort(logits, descending=True)
+            cum = torch.cumsum(torch.softmax(sorted_l, -1), -1)
+            remove = cum > top_p
+            remove[:, 1:] = remove[:, :-1].clone()
+            remove[:, 0] = False
+            logits[remove.scatter(1, sorted_i, remove)] = float("-inf")
+
+        next_tok = torch.multinomial(torch.softmax(logits, -1), 1)
+        tok_id = next_tok.item()
+
+        if tok_id == END_OF_SPEECH_TOKEN_ID:
+            break
+
+        generated_tokens.append(tok_id)
+        dec_ids = torch.cat([dec_ids, next_tok], dim=-1)
+
+    if not generated_tokens:
+        return None
+
+    result = torch.tensor(generated_tokens, dtype=torch.long)
+    audio_mask = (result >= AUDIO_OFFSET) & (result < AUDIO_OFFSET + NUM_AUDIO_TOKENS)
+    return result[audio_mask] - AUDIO_OFFSET
+
+
+def synthesize(checkpoint, text, output="output.wav",
+               speaker_wav=None, speaker_emb_path=None,
+               temperature=0.7, top_k=250, top_p=0.95,
+               rep_penalty=1.1, max_tokens=512, device="cuda"):
+    """
+    Full TTS pipeline: text → audio file.
+
+    Speaker can be provided as:
+      1. speaker_wav: path to reference audio (will encode with MioCodec)
+      2. speaker_emb_path: path to saved .pt embedding
+    """
+    print(f"'{text[:80]}' | T={temperature}")
+    model = load_for_inference(checkpoint, device=device)
+    tokenizer = TTSTokenizer()
+    codec = CodecV6(device=device)
+
+    # Get speaker embedding
+    if speaker_emb_path:
+        import numpy as np
+        if speaker_emb_path.endswith('.npy'):
+            speaker_emb = torch.from_numpy(np.load(speaker_emb_path)).to(device)
+        else:
+            speaker_emb = torch.load(speaker_emb_path, map_location=device, weights_only=False)
+        if isinstance(speaker_emb, dict):
+            speaker_emb = speaker_emb.get("global_embedding",
+                                           speaker_emb.get("embedding"))
+        if speaker_emb.dim() > 1:
+            speaker_emb = speaker_emb.squeeze()
+        print(f"Speaker from preset: {speaker_emb.shape}")
+    elif speaker_wav:
+        result = codec.encode(speaker_wav)
+        speaker_emb = result['global_embedding'].to(device)
+        print(f"Speaker from wav: {speaker_wav}")
+    else:
+        raise ValueError("Provide speaker_wav or speaker_emb_path")
+
+    # Split long text into chunks that fit encoder max_text_len
+    chunks = _split_text(text, tokenizer, max_len=250)
+    print(f"Text split into {len(chunks)} chunk(s)")
+
+    t0 = time.time()
+    all_codes = []
+    for i, chunk in enumerate(chunks):
+        enc_len = len(tokenizer.build_encoder_input(chunk))
+        print(f"  [{i+1}/{len(chunks)}] {enc_len} enc tokens: '{chunk[:60]}...'")
+        codes = generate(model, tokenizer, chunk, speaker_emb, max_tokens,
+                         temperature, top_k, top_p, rep_penalty, device)
+        if codes is not None and len(codes) > 0:
+            all_codes.append(codes)
+    gen_time = time.time() - t0
+
+    if not all_codes:
+        print("No audio generated!")
+        return
+
+    codes = torch.cat(all_codes)
+    audio_dur = len(codes) / CODEC_FRAME_RATE
+    rtf = gen_time / audio_dur if audio_dur > 0 else float('inf')
+    print(f"{len(codes)} tokens ({audio_dur:.1f}s audio, {gen_time:.2f}s gen, RTF={rtf:.3f})")
+
+    # Decode to wav
+    wav = codec.tokens_to_wav(codes, speaker_emb, output)
+    print(f"Saved: {output} ({len(wav)/CODEC_SAMPLE_RATE:.2f}s)")
+    return wav
+
+
+def main():
+    p = argparse.ArgumentParser(description="V6 TTS Inference")
+    p.add_argument("--checkpoint", required=True)
+    p.add_argument("--text", required=True)
+    p.add_argument("--output", default="output.wav")
+    p.add_argument("--speaker-wav", help="Reference audio for voice cloning")
+    p.add_argument("--speaker-emb", help="Path to saved speaker embedding .pt")
+    p.add_argument("--temperature", type=float, default=0.7)
+    p.add_argument("--top-k", type=int, default=250)
+    p.add_argument("--top-p", type=float, default=0.95)
+    p.add_argument("--rep-penalty", type=float, default=1.1)
+    p.add_argument("--max-tokens", type=int, default=512)
+    a = p.parse_args()
+    synthesize(a.checkpoint, a.text, a.output,
+               speaker_wav=a.speaker_wav,
+               speaker_emb_path=a.speaker_emb,
+               temperature=a.temperature, top_k=a.top_k,
+               top_p=a.top_p, rep_penalty=a.rep_penalty,
+               max_tokens=a.max_tokens)
+
+if __name__ == "__main__":
+    main()

BgTTS/model.py

@@ -0,0 +1,600 @@
+"""
+V6 Model — Encoder-Decoder TTS with MioCodec + Speaker Embedding
+=================================================================
+Architecture (V6 Small):
+  - Text Encoder: 4-layer bidirectional Transformer (d=384, 6 heads, ff=1536)
+    Learned positional embeddings, RMSNorm, SwiGLU
+  - Audio Decoder: 8-layer causal Transformer (d=384, 6 heads, ff=1536)
+    RoPE, cross-attention to encoder at every layer, RMSNorm, SwiGLU
+  - Speaker Projection: Linear(128, 384) — MioCodec global_embedding → decoder dim
+
+Key design:
+  - enc_d == dec_d == 384 → no projection layer needed
+  - Speaker embedding (128-dim) injected into decoder as additive bias
+  - Tied decoder embeddings (lm_head = token_embedding.weight)
+  - Gradient checkpointing in decoder during training
+  - KV-cache for inference
+  - ~38M params total
+
+Target inference: RTF ~0.25-0.30 on RTX 5090
+"""
+
+import math
+import os
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from typing import Optional, Tuple, Dict
+from dataclasses import dataclass
+
+from config import (
+    TOTAL_VOCAB_SIZE, ENCODER_VOCAB_SIZE, DECODER_VOCAB_SIZE,
+    ENC_D_MODEL, ENC_N_HEADS, ENC_N_LAYERS, ENC_D_FF,
+    DEC_D_MODEL, DEC_N_HEADS, DEC_N_LAYERS, DEC_D_FF,
+    MAX_TEXT_LEN, MAX_AUDIO_LEN, DROPOUT,
+    PAD_TOKEN_ID, NUM_AUDIO_TOKENS, AUDIO_OFFSET,
+    SPEAKER_EMB_DIM,
+)
+
+
+# ── Shared Components ──────────────────────────────────────────
+
+class RMSNorm(nn.Module):
+    def __init__(self, dim: int, eps: float = 1e-6):
+        super().__init__()
+        self.eps = eps
+        self.weight = nn.Parameter(torch.ones(dim))
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        return x * torch.rsqrt(x.pow(2).mean(-1, keepdim=True) + self.eps) * self.weight
+
+
+class RotaryPositionalEmbedding(nn.Module):
+    def __init__(self, dim: int, max_seq_len: int = 4096, base: float = 10000.0):
+        super().__init__()
+        self.dim = dim
+        self.max_seq_len = max_seq_len
+        inv_freq = 1.0 / (base ** (torch.arange(0, dim, 2).float() / dim))
+        self.register_buffer("inv_freq", inv_freq, persistent=False)
+        self._build_cache(max_seq_len)
+
+    def _build_cache(self, seq_len: int):
+        t = torch.arange(seq_len, device=self.inv_freq.device, dtype=self.inv_freq.dtype)
+        freqs = torch.outer(t, self.inv_freq)
+        emb = torch.cat((freqs, freqs), dim=-1)
+        self.register_buffer("cos_cached", emb.cos(), persistent=False)
+        self.register_buffer("sin_cached", emb.sin(), persistent=False)
+
+    def forward(self, seq_len: int) -> Tuple[torch.Tensor, torch.Tensor]:
+        if seq_len > self.max_seq_len:
+            self._build_cache(seq_len)
+            self.max_seq_len = seq_len
+        return self.cos_cached[:seq_len], self.sin_cached[:seq_len]
+
+
+def rotate_half(x: torch.Tensor) -> torch.Tensor:
+    x1, x2 = x.chunk(2, dim=-1)
+    return torch.cat((-x2, x1), dim=-1)
+
+
+def apply_rotary_pos_emb(q, k, cos, sin):
+    cos = cos.unsqueeze(0).unsqueeze(0)
+    sin = sin.unsqueeze(0).unsqueeze(0)
+    return (q * cos + rotate_half(q) * sin,
+            k * cos + rotate_half(k) * sin)
+
+
+class SwiGLUFFN(nn.Module):
+    def __init__(self, d_model: int, d_ff: int, dropout: float):
+        super().__init__()
+        self.gate_proj = nn.Linear(d_model, d_ff, bias=False)
+        self.up_proj   = nn.Linear(d_model, d_ff, bias=False)
+        self.down_proj = nn.Linear(d_ff, d_model, bias=False)
+        self.dropout   = nn.Dropout(dropout)
+
+    def forward(self, x):
+        return self.dropout(self.down_proj(F.silu(self.gate_proj(x)) * self.up_proj(x)))
+
+
+# ── Encoder (Bidirectional) ────────────────────────────────────
+
+class EncoderSelfAttention(nn.Module):
+    """Bidirectional self-attention for text encoder (NO causal mask)."""
+    def __init__(self, d_model: int, n_heads: int, dropout: float):
+        super().__init__()
+        self.d_model = d_model
+        self.n_heads = n_heads
+        self.head_dim = d_model // n_heads
+        assert d_model % n_heads == 0
+
+        self.q_proj = nn.Linear(d_model, d_model, bias=False)
+        self.k_proj = nn.Linear(d_model, d_model, bias=False)
+        self.v_proj = nn.Linear(d_model, d_model, bias=False)
+        self.o_proj = nn.Linear(d_model, d_model, bias=False)
+        self.resid_dropout = nn.Dropout(dropout)
+
+    def forward(self, x, key_padding_mask=None):
+        B, T, _ = x.shape
+        q = self.q_proj(x).view(B, T, self.n_heads, self.head_dim).transpose(1, 2)
+        k = self.k_proj(x).view(B, T, self.n_heads, self.head_dim).transpose(1, 2)
+        v = self.v_proj(x).view(B, T, self.n_heads, self.head_dim).transpose(1, 2)
+
+        attn_mask = None
+        if key_padding_mask is not None:
+            attn_mask = key_padding_mask.unsqueeze(1).unsqueeze(2)  # [B, 1, 1, T]
+            attn_mask = attn_mask.float() * torch.finfo(q.dtype).min
+
+        attn_out = F.scaled_dot_product_attention(
+            q, k, v,
+            attn_mask=attn_mask,
+            dropout_p=self.resid_dropout.p if self.training else 0.0,
+            is_causal=False,
+        )
+        attn_out = attn_out.transpose(1, 2).contiguous().view(B, -1, self.d_model)
+        return self.resid_dropout(self.o_proj(attn_out))
+
+
+class EncoderBlock(nn.Module):
+    def __init__(self, d_model: int, n_heads: int, d_ff: int, dropout: float):
+        super().__init__()
+        self.attn_norm = RMSNorm(d_model)
+        self.attention = EncoderSelfAttention(d_model, n_heads, dropout)
+        self.ffn_norm  = RMSNorm(d_model)
+        self.ffn       = SwiGLUFFN(d_model, d_ff, dropout)
+
+    def forward(self, x, key_padding_mask=None):
+        x = x + self.attention(self.attn_norm(x), key_padding_mask)
+        x = x + self.ffn(self.ffn_norm(x))
+        return x
+
+
+class TextEncoder(nn.Module):
+    """
+    Bidirectional Transformer encoder for text.
+    Input: text token IDs (special + chars, vocab 155)
+    Output: contextualized text representations [B, T_text, d_model]
+    """
+    def __init__(self, vocab_size=ENCODER_VOCAB_SIZE, d_model=ENC_D_MODEL,
+                 n_heads=ENC_N_HEADS, n_layers=ENC_N_LAYERS, d_ff=ENC_D_FF,
+                 max_len=MAX_TEXT_LEN, dropout=DROPOUT):
+        super().__init__()
+        self.d_model = d_model
+        self.token_embedding = nn.Embedding(vocab_size, d_model, padding_idx=PAD_TOKEN_ID)
+        self.pos_embedding = nn.Embedding(max_len, d_model)
+        self.embed_dropout = nn.Dropout(dropout)
+
+        self.layers = nn.ModuleList([
+            EncoderBlock(d_model, n_heads, d_ff, dropout)
+            for _ in range(n_layers)
+        ])
+        self.final_norm = RMSNorm(d_model)
+
+    def forward(self, input_ids, attention_mask=None):
+        B, T = input_ids.shape
+        pos = torch.arange(T, device=input_ids.device).unsqueeze(0)
+        h = self.embed_dropout(self.token_embedding(input_ids) + self.pos_embedding(pos))
+
+        key_padding_mask = None
+        if attention_mask is not None:
+            key_padding_mask = (attention_mask == 0)
+
+        for layer in self.layers:
+            h = layer(h, key_padding_mask)
+
+        return self.final_norm(h)
+
+
+# ── Decoder (Causal with Cross-Attention + Speaker) ────────────
+
+class DecoderSelfAttention(nn.Module):
+    """Causal self-attention with RoPE and KV-cache."""
+    def __init__(self, d_model: int, n_heads: int, dropout: float, max_len: int):
+        super().__init__()
+        self.d_model = d_model
+        self.n_heads = n_heads
+        self.head_dim = d_model // n_heads
+        assert d_model % n_heads == 0
+
+        self.q_proj = nn.Linear(d_model, d_model, bias=False)
+        self.k_proj = nn.Linear(d_model, d_model, bias=False)
+        self.v_proj = nn.Linear(d_model, d_model, bias=False)
+        self.o_proj = nn.Linear(d_model, d_model, bias=False)
+        self.resid_dropout = nn.Dropout(dropout)
+        self.rope = RotaryPositionalEmbedding(self.head_dim, max_len)
+
+    def forward(self, x, past_kv=None, use_cache=False):
+        B, T, _ = x.shape
+        q = self.q_proj(x).view(B, T, self.n_heads, self.head_dim).transpose(1, 2)
+        k = self.k_proj(x).view(B, T, self.n_heads, self.head_dim).transpose(1, 2)
+        v = self.v_proj(x).view(B, T, self.n_heads, self.head_dim).transpose(1, 2)
+
+        # RoPE
+        if past_kv is not None:
+            offset = past_kv[0].shape[2]
+            cos, sin = self.rope(offset + T)
+            cos, sin = cos[offset:offset + T], sin[offset:offset + T]
+        else:
+            cos, sin = self.rope(T)
+
+        q, k = apply_rotary_pos_emb(q, k, cos, sin)
+
+        if past_kv is not None:
+            k = torch.cat([past_kv[0], k], dim=2)
+            v = torch.cat([past_kv[1], v], dim=2)
+
+        new_kv = (k, v) if use_cache else None
+
+        is_causal = (past_kv is None) and (T > 1)
+        attn_out = F.scaled_dot_product_attention(
+            q, k, v,
+            dropout_p=self.resid_dropout.p if self.training else 0.0,
+            is_causal=is_causal,
+        )
+        attn_out = attn_out.transpose(1, 2).contiguous().view(B, -1, self.d_model)
+        return self.resid_dropout(self.o_proj(attn_out)), new_kv
+
+
+class CrossAttention(nn.Module):
+    """Cross-attention: decoder queries attend to encoder keys/values."""
+    def __init__(self, d_model: int, n_heads: int, dropout: float):
+        super().__init__()
+        self.d_model = d_model
+        self.n_heads = n_heads
+        self.head_dim = d_model // n_heads
+        assert d_model % n_heads == 0
+
+        # Q from decoder, K/V from encoder — same dim since enc_d == dec_d
+        self.q_proj = nn.Linear(d_model, d_model, bias=False)
+        self.k_proj = nn.Linear(d_model, d_model, bias=False)
+        self.v_proj = nn.Linear(d_model, d_model, bias=False)
+        self.o_proj = nn.Linear(d_model, d_model, bias=False)
+        self.resid_dropout = nn.Dropout(dropout)
+
+    def forward(self, x, encoder_output, encoder_mask=None, cached_kv=None, use_cache=False):
+        B, T, _ = x.shape
+        q = self.q_proj(x).view(B, T, self.n_heads, self.head_dim).transpose(1, 2)
+
+        if cached_kv is not None:
+            k, v = cached_kv
+        else:
+            T_enc = encoder_output.shape[1]
+            k = self.k_proj(encoder_output).view(B, T_enc, self.n_heads, self.head_dim).transpose(1, 2)
+            v = self.v_proj(encoder_output).view(B, T_enc, self.n_heads, self.head_dim).transpose(1, 2)
+
+        new_kv = (k, v) if use_cache else None
+
+        attn_mask = None
+        if encoder_mask is not None:
+            attn_mask = (encoder_mask == 0).unsqueeze(1).unsqueeze(2)
+            attn_mask = attn_mask.float() * torch.finfo(q.dtype).min
+
+        attn_out = F.scaled_dot_product_attention(
+            q, k, v,
+            attn_mask=attn_mask,
+            dropout_p=self.resid_dropout.p if self.training else 0.0,
+            is_causal=False,
+        )
+        attn_out = attn_out.transpose(1, 2).contiguous().view(B, -1, self.d_model)
+        return self.resid_dropout(self.o_proj(attn_out)), new_kv
+
+
+class DecoderBlock(nn.Module):
+    """Decoder block: self-attention → cross-attention → FFN"""
+    def __init__(self, d_model: int, n_heads: int, d_ff: int,
+                 dropout: float, max_len: int):
+        super().__init__()
+        self.self_attn_norm = RMSNorm(d_model)
+        self.self_attention = DecoderSelfAttention(d_model, n_heads, dropout, max_len)
+
+        self.cross_attn_norm = RMSNorm(d_model)
+        self.cross_attention = CrossAttention(d_model, n_heads, dropout)
+
+        self.ffn_norm = RMSNorm(d_model)
+        self.ffn = SwiGLUFFN(d_model, d_ff, dropout)
+
+    def forward(self, x, encoder_output, encoder_mask=None,
+                past_self_kv=None, past_cross_kv=None, use_cache=False):
+        # 1. Causal self-attention
+        h = self.self_attn_norm(x)
+        attn_out, new_self_kv = self.self_attention(h, past_self_kv, use_cache)
+        x = x + attn_out
+
+        # 2. Cross-attention to encoder
+        h = self.cross_attn_norm(x)
+        cross_out, new_cross_kv = self.cross_attention(
+            h, encoder_output, encoder_mask, past_cross_kv, use_cache)
+        x = x + cross_out
+
+        # 3. FFN
+        x = x + self.ffn(self.ffn_norm(x))
+
+        return x, new_self_kv, new_cross_kv
+
+
+class AudioDecoder(nn.Module):
+    """
+    Causal Transformer decoder with cross-attention + speaker embedding.
+    Speaker embedding is added once to the token embeddings (like a global bias).
+    """
+    def __init__(self, vocab_size=DECODER_VOCAB_SIZE, d_model=DEC_D_MODEL,
+                 n_heads=DEC_N_HEADS, n_layers=DEC_N_LAYERS, d_ff=DEC_D_FF,
+                 max_len=MAX_AUDIO_LEN, dropout=DROPOUT,
+                 speaker_emb_dim=SPEAKER_EMB_DIM):
+        super().__init__()
+        self.config_d_model = d_model
+        self.token_embedding = nn.Embedding(vocab_size, d_model)
+        self.embed_dropout = nn.Dropout(dropout)
+
+        # Speaker embedding projection: 128 → d_model (normalized)
+        self.speaker_proj = nn.Linear(speaker_emb_dim, d_model, bias=False)
+        self.register_buffer('spk_scale', torch.ones(1))  # fixed scale, not learnable
+
+        self.layers = nn.ModuleList([
+            DecoderBlock(d_model, n_heads, d_ff, dropout, max_len)
+            for _ in range(n_layers)
+        ])
+        self.final_norm = RMSNorm(d_model)
+
+        # LM head — tied with token embedding
+        self.lm_head = None  # tied
+
+    def forward(self, input_ids, encoder_output, encoder_mask=None,
+                speaker_emb=None, labels=None,
+                past_key_values=None, use_cache=False):
+        """
+        input_ids:      [B, T_dec]
+        encoder_output: [B, T_enc, d_model]
+        encoder_mask:   [B, T_enc]
+        speaker_emb:    [B, 128] — MioCodec global_embedding
+        labels:         [B, T_dec] — for training
+        """
+        h = self.token_embedding(input_ids)
+
+        # Inject speaker embedding — normalized, additive, broadcast over time
+        if speaker_emb is not None:
+            spk = self.speaker_proj(speaker_emb)  # [B, d_model]
+            spk = F.normalize(spk, dim=-1) * self.spk_scale  # normalize to unit norm
+            h = h + spk.unsqueeze(1)  # [B, 1, d_model] broadcast
+
+        h = self.embed_dropout(h)
+
+        new_kvs = [] if use_cache else None
+        for i, layer in enumerate(self.layers):
+            past_self_kv = past_key_values[i][0] if past_key_values else None
+            past_cross_kv = past_key_values[i][1] if past_key_values else None
+
+            if self.training and not use_cache:
+                h, self_kv, cross_kv = torch.utils.checkpoint.checkpoint(
+                    layer, h, encoder_output, encoder_mask,
+                    past_self_kv, past_cross_kv, use_cache,
+                    use_reentrant=False)
+            else:
+                h, self_kv, cross_kv = layer(
+                    h, encoder_output, encoder_mask,
+                    past_self_kv, past_cross_kv, use_cache)
+
+            if use_cache:
+                new_kvs.append((self_kv, cross_kv))
+
+        h = self.final_norm(h)
+
+        # Tied embeddings
+        logits = F.linear(h, self.token_embedding.weight)
+
+        result = {"logits": logits}
+        if use_cache:
+            result["past_key_values"] = new_kvs
+
+        if labels is not None:
+            shift_logits = logits[:, :-1, :].contiguous()
+            shift_labels = labels[:, 1:].contiguous()
+            loss = F.cross_entropy(
+                shift_logits.view(-1, shift_logits.size(-1)),
+                shift_labels.view(-1),
+                ignore_index=-100,
+            )
+            result["loss"] = loss
+
+        return result
+
+
+# ── Full Encoder-Decoder Model ─────────────────────────────────
+
+@dataclass
+class V6Config:
+    # Encoder
+    enc_vocab_size: int = ENCODER_VOCAB_SIZE
+    enc_d_model: int = ENC_D_MODEL
+    enc_n_heads: int = ENC_N_HEADS
+    enc_n_layers: int = ENC_N_LAYERS
+    enc_d_ff: int = ENC_D_FF
+    max_text_len: int = MAX_TEXT_LEN
+    # Decoder
+    dec_vocab_size: int = DECODER_VOCAB_SIZE
+    dec_d_model: int = DEC_D_MODEL
+    dec_n_heads: int = DEC_N_HEADS
+    dec_n_layers: int = DEC_N_LAYERS
+    dec_d_ff: int = DEC_D_FF
+    max_audio_len: int = MAX_AUDIO_LEN
+    # Speaker
+    speaker_emb_dim: int = SPEAKER_EMB_DIM
+    # Shared
+    dropout: float = DROPOUT
+
+
+class TTSEncoderDecoder(nn.Module):
+    """
+    V6 Encoder-Decoder TTS with MioCodec + Speaker Embedding.
+
+    Forward flow:
+    1. Text → Encoder → contextualized text representations [B, T_text, d_model]
+    2. Audio tokens + speaker_emb → Decoder (with cross-attn) → logits
+    """
+    def __init__(self, config: V6Config):
+        super().__init__()
+        self.config = config
+
+        # Text encoder (bidirectional)
+        self.encoder = TextEncoder(
+            vocab_size=config.enc_vocab_size,
+            d_model=config.enc_d_model,
+            n_heads=config.enc_n_heads,
+            n_layers=config.enc_n_layers,
+            d_ff=config.enc_d_ff,
+            max_len=config.max_text_len,
+            dropout=config.dropout,
+        )
+
+        # enc_d == dec_d → identity projection (no extra params)
+        assert config.enc_d_model == config.dec_d_model, \
+            f"V6 requires enc_d == dec_d, got {config.enc_d_model} vs {config.dec_d_model}"
+
+        # Audio decoder (causal with cross-attention + speaker embedding)
+        self.decoder = AudioDecoder(
+            vocab_size=config.dec_vocab_size,
+            d_model=config.dec_d_model,
+            n_heads=config.dec_n_heads,
+            n_layers=config.dec_n_layers,
+            d_ff=config.dec_d_ff,
+            max_len=config.max_audio_len,
+            dropout=config.dropout,
+            speaker_emb_dim=config.speaker_emb_dim,
+        )
+
+        self.apply(self._init_weights)
+
+    def _init_weights(self, module):
+        if isinstance(module, nn.Linear):
+            nn.init.normal_(module.weight, mean=0.0, std=0.02)
+            if module.bias is not None:
+                nn.init.zeros_(module.bias)
+        elif isinstance(module, nn.Embedding):
+            nn.init.normal_(module.weight, mean=0.0, std=0.02)
+
+    def get_num_params(self) -> int:
+        return sum(p.numel() for p in self.parameters())
+
+    def encode(self, enc_ids, enc_mask=None):
+        """Run encoder. Returns [B, T_enc, d_model]."""
+        return self.encoder(enc_ids, enc_mask)
+
+    def forward(self, enc_ids, dec_ids, enc_mask=None, dec_labels=None,
+                speaker_emb=None):
+        """
+        Full forward: encoder → decoder → loss.
+
+        Args:
+            enc_ids:      [B, T_enc] — text token IDs
+            dec_ids:      [B, T_dec] — audio token IDs (decoder input)
+            enc_mask:     [B, T_enc] — 1=real, 0=pad
+            dec_labels:   [B, T_dec] — decoder labels (-100 for masked)
+            speaker_emb:  [B, 128] — MioCodec global_embedding
+        """
+        # 1. Encode text
+        enc_out = self.encoder(enc_ids, enc_mask)  # [B, T_enc, d_model]
+
+        # 2. Decode audio with cross-attention + speaker
+        dec_out = self.decoder(dec_ids, enc_out, enc_mask,
+                               speaker_emb=speaker_emb, labels=dec_labels)
+
+        result = {"logits": dec_out["logits"]}
+        if "loss" in dec_out:
+            result["loss"] = dec_out["loss"]
+
+        return result
+
+
+# ── Factory functions ──────────────────────────────────────────
+
+def create_model(device="cuda", dropout_override=None) -> TTSEncoderDecoder:
+    """Create V6 encoder-decoder TTS model."""
+    kwargs = {}
+    if dropout_override is not None:
+        kwargs["dropout"] = dropout_override
+    config = V6Config(**kwargs)
+    model = TTSEncoderDecoder(config)
+
+    n = model.get_num_params()
+    enc_n = sum(p.numel() for p in model.encoder.parameters())
+    dec_n = sum(p.numel() for p in model.decoder.parameters())
+
+    print(f"V6 Encoder-Decoder TTS with MioCodec + Speaker Embedding")
+    print(f"   Total params:  {n:,} ({n/1e6:.1f}M)")
+    print(f"   Encoder:       {enc_n:,} ({enc_n/1e6:.1f}M)")
+    print(f"   Decoder:       {dec_n:,} ({dec_n/1e6:.1f}M)")
+    print(f"   Enc: d={config.enc_d_model}, h={config.enc_n_heads}, "
+          f"L={config.enc_n_layers}, ff={config.enc_d_ff}")
+    print(f"   Dec: d={config.dec_d_model}, h={config.dec_n_heads}, "
+          f"L={config.dec_n_layers}, ff={config.dec_d_ff}")
+    print(f"   Speaker: {config.speaker_emb_dim}-dim → {config.dec_d_model}")
+    print(f"   Dropout: {config.dropout}")
+
+    model = model.to(device)
+    return model
+
+
+def save_checkpoint(model, optimizer, scheduler, step, loss, path, best_val_loss=None):
+    """Save full training checkpoint."""
+    os.makedirs(path, exist_ok=True)
+    model_to_save = model._orig_mod if hasattr(model, "_orig_mod") else model
+
+    torch.save({
+        "model_state_dict": model_to_save.state_dict(),
+        "optimizer_state_dict": optimizer.state_dict(),
+        "scheduler_state_dict": scheduler.state_dict() if scheduler else None,
+        "step": step,
+        "loss": loss,
+        "best_val_loss": best_val_loss,
+        "config": {
+            "enc_vocab_size": model_to_save.config.enc_vocab_size,
+            "enc_d_model": model_to_save.config.enc_d_model,
+            "enc_n_heads": model_to_save.config.enc_n_heads,
+            "enc_n_layers": model_to_save.config.enc_n_layers,
+            "enc_d_ff": model_to_save.config.enc_d_ff,
+            "max_text_len": model_to_save.config.max_text_len,
+            "dec_vocab_size": model_to_save.config.dec_vocab_size,
+            "dec_d_model": model_to_save.config.dec_d_model,
+            "dec_n_heads": model_to_save.config.dec_n_heads,
+            "dec_n_layers": model_to_save.config.dec_n_layers,
+            "dec_d_ff": model_to_save.config.dec_d_ff,
+            "max_audio_len": model_to_save.config.max_audio_len,
+            "speaker_emb_dim": model_to_save.config.speaker_emb_dim,
+            "dropout": model_to_save.config.dropout,
+        },
+    }, f"{path}/checkpoint.pt")
+    print(f"Saved: {path} (step {step}, loss {loss:.4f})")
+
+
+def load_for_inference(checkpoint_path: str, device="cuda") -> TTSEncoderDecoder:
+    """Load model from checkpoint for inference."""
+    if os.path.isfile(checkpoint_path):
+        ckpt_file = checkpoint_path
+    else:
+        ckpt_file = os.path.join(checkpoint_path, "checkpoint.pt")
+    print(f"Loading from {ckpt_file}...")
+    ckpt = torch.load(ckpt_file, map_location=device, weights_only=False)
+
+    cfg = ckpt["config"]
+    config = V6Config(
+        enc_vocab_size=cfg["enc_vocab_size"],
+        enc_d_model=cfg["enc_d_model"],
+        enc_n_heads=cfg["enc_n_heads"],
+        enc_n_layers=cfg["enc_n_layers"],
+        enc_d_ff=cfg["enc_d_ff"],
+        max_text_len=cfg["max_text_len"],
+        dec_vocab_size=cfg["dec_vocab_size"],
+        dec_d_model=cfg["dec_d_model"],
+        dec_n_heads=cfg["dec_n_heads"],
+        dec_n_layers=cfg["dec_n_layers"],
+        dec_d_ff=cfg["dec_d_ff"],
+        max_audio_len=cfg["max_audio_len"],
+        speaker_emb_dim=cfg.get("speaker_emb_dim", SPEAKER_EMB_DIM),
+        dropout=cfg["dropout"],
+    )
+    model = TTSEncoderDecoder(config)
+    model.load_state_dict(ckpt["model_state_dict"])
+    model = model.to(device).eval()
+
+    n = model.get_num_params()
+    print(f"Loaded! {n/1e6:.1f}M params, step {ckpt['step']}, loss {ckpt['loss']:.4f}")
+    return model

BgTTS/server.py

@@ -0,0 +1,222 @@
+"""
+BgTTS-38M Web Server — Gradio Interface
+========================================
+Voice cloning TTS with Bulgarian + English support.
+"""
+
+import sys
+import os
+import torch
+import numpy as np
+import tempfile
+import time
+import soundfile as sf
+
+# Add parent dir to path for imports
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+
+from config import (
+    AUDIO_OFFSET, NUM_AUDIO_TOKENS, END_OF_SPEECH_TOKEN_ID,
+    START_OF_SPEECH_TOKEN_ID, CODEC_SAMPLE_RATE, CODEC_FRAME_RATE,
+)
+from tokenizer import TTSTokenizer
+from codec import CodecV6
+from model import load_for_inference
+from inference import generate, _split_text
+
+# ── Global state ──────────────────────────────────────────────
+MODEL = None
+TOKENIZER = None
+CODEC = None
+DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
+CHECKPOINT_PATH = os.path.join(os.path.dirname(os.path.abspath(__file__)), "checkpoint_inference.pt")
+
+
+def load_model():
+    """Load model, tokenizer, codec once at startup."""
+    global MODEL, TOKENIZER, CODEC
+    print(f"Loading model from {CHECKPOINT_PATH} on {DEVICE}...")
+    MODEL = load_for_inference(CHECKPOINT_PATH, device=DEVICE)
+    TOKENIZER = TTSTokenizer()
+    CODEC = CodecV6(device=DEVICE)
+    print("Model loaded!")
+
+
+def synthesize_speech(text, ref_audio, temperature, top_k, top_p, rep_penalty):
+    """
+    Generate speech from text using reference audio for voice cloning.
+    
+    Returns: (sample_rate, audio_array) tuple for Gradio
+    """
+    if not text or not text.strip():
+        return None
+    
+    if ref_audio is None:
+        return None
+    
+    # Encode reference audio for speaker embedding
+    sr_ref, audio_ref = ref_audio
+    audio_ref = audio_ref.astype(np.float32)
+    if audio_ref.max() > 1.0 or audio_ref.min() < -1.0:
+        audio_ref = audio_ref / max(abs(audio_ref.max()), abs(audio_ref.min()))
+    
+    waveform = torch.from_numpy(audio_ref)
+    if waveform.dim() == 2:
+        waveform = waveform.mean(1)
+    
+    result = CODEC.encode_waveform(waveform, sr_ref)
+    speaker_emb = result['global_embedding'].to(DEVICE)
+    
+    # Split text into chunks
+    chunks = _split_text(text, TOKENIZER, max_len=250)
+    
+    t0 = time.time()
+    all_codes = []
+    for chunk in chunks:
+        codes = generate(
+            MODEL, TOKENIZER, chunk, speaker_emb,
+            max_new_tokens=512,
+            temperature=temperature,
+            top_k=int(top_k),
+            top_p=top_p,
+            rep_penalty=rep_penalty,
+            device=DEVICE
+        )
+        if codes is not None and len(codes) > 0:
+            all_codes.append(codes)
+    
+    gen_time = time.time() - t0
+    
+    if not all_codes:
+        return None
+    
+    codes = torch.cat(all_codes)
+    audio_dur = len(codes) / CODEC_FRAME_RATE
+    rtf = gen_time / audio_dur if audio_dur > 0 else float('inf')
+    
+    # Decode to waveform
+    wav = CODEC.decode(codes, speaker_emb)
+    wav_np = wav.numpy()
+    
+    info = f"✅ {len(codes)} tokens | {audio_dur:.1f}s audio | {gen_time:.1f}s gen | RTF: {rtf:.3f}"
+    
+    return (CODEC_SAMPLE_RATE, wav_np), info
+
+
+def build_ui():
+    """Build Gradio interface."""
+    import gradio as gr
+    
+    with gr.Blocks(
+        title="BgTTS-38M — Bulgarian Text-to-Speech",
+        theme=gr.themes.Soft(
+            primary_hue="blue",
+            secondary_hue="slate",
+        ),
+        css="""
+        .main-title { text-align: center; margin-bottom: 0.5em; }
+        .subtitle { text-align: center; color: #666; margin-bottom: 1.5em; }
+        """
+    ) as app:
+        gr.HTML('<h1 class="main-title">🎙️ BgTTS-38M</h1>')
+        gr.HTML('<p class="subtitle">Bulgarian + English Text-to-Speech with Voice Cloning | 38M params | 153MB</p>')
+        
+        with gr.Row():
+            with gr.Column(scale=2):
+                text_input = gr.Textbox(
+                    label="Текст / Text",
+                    placeholder="Въведете текст на български или английски...\nEnter text in Bulgarian or English...",
+                    lines=5,
+                    max_lines=15,
+                )
+                
+                ref_audio = gr.Audio(
+                    label="🎤 Reference Voice (за клониране на глас)",
+                    type="numpy",
+                    sources=["upload", "microphone"],
+                )
+                
+                with gr.Row():
+                    generate_btn = gr.Button("🔊 Генерирай / Generate", variant="primary", size="lg")
+                    clear_btn = gr.Button("🗑️ Изчисти", size="lg")
+                
+            with gr.Column(scale=1):
+                with gr.Accordion("⚙️ Настройки / Settings", open=False):
+                    temperature = gr.Slider(
+                        minimum=0.05, maximum=1.5, value=0.3, step=0.05,
+                        label="Temperature",
+                        info="По-ниска = по-чисто, по-висока = по-разнообразно"
+                    )
+                    top_k = gr.Slider(
+                        minimum=1, maximum=500, value=250, step=10,
+                        label="Top-K"
+                    )
+                    top_p = gr.Slider(
+                        minimum=0.1, maximum=1.0, value=0.95, step=0.05,
+                        label="Top-P (Nucleus)"
+                    )
+                    rep_penalty = gr.Slider(
+                        minimum=1.0, maximum=2.0, value=1.1, step=0.05,
+                        label="Repetition Penalty"
+                    )
+                
+                output_audio = gr.Audio(
+                    label="🔊 Резултат / Output",
+                    type="numpy",
+                    interactive=False,
+                )
+                
+                info_text = gr.Textbox(
+                    label="ℹ️ Информация",
+                    interactive=False,
+                    lines=2,
+                )
+        
+        # Examples
+        gr.Examples(
+            examples=[
+                ["Българският език е изключително богат и мелодичен."],
+                ["Artificial intelligence has reached a fascinating stage."],
+                ["Когато говорим за истински multitasking, способността ми да превключвам плавно между български и English е от огромно значение."],
+                ["Здравейте! Казвам се Ани и мога да говоря на български и английски."],
+                ["The quick brown fox jumps over the lazy dog."],
+            ],
+            inputs=[text_input],
+            label="📝 Примери / Examples",
+        )
+        
+        # Event handlers
+        generate_btn.click(
+            fn=synthesize_speech,
+            inputs=[text_input, ref_audio, temperature, top_k, top_p, rep_penalty],
+            outputs=[output_audio, info_text],
+        )
+        
+        clear_btn.click(
+            fn=lambda: (None, None, ""),
+            outputs=[text_input, output_audio, info_text],
+        )
+    
+    return app
+
+
+if __name__ == "__main__":
+    import argparse
+    p = argparse.ArgumentParser()
+    p.add_argument("--checkpoint", default=CHECKPOINT_PATH)
+    p.add_argument("--host", default="0.0.0.0")
+    p.add_argument("--port", type=int, default=7860)
+    p.add_argument("--share", action="store_true")
+    p.add_argument("--device", default=DEVICE)
+    args = p.parse_args()
+    
+    CHECKPOINT_PATH = args.checkpoint
+    DEVICE = args.device
+    
+    load_model()
+    app = build_ui()
+    app.launch(
+        server_name=args.host,
+        server_port=args.port,
+        share=args.share,
+    )

BgTTS/tokenizer.py

@@ -0,0 +1,100 @@
+"""
+V6 Tokenizer — char-level for Bulgarian TTS with MioCodec
+==========================================================
+Same character set as V5, but adapted for:
+  - MioCodec single codebook (no interleaving)
+  - Speaker embedding (no speaker tokens in encoder input)
+"""
+
+import re
+import torch
+from typing import Optional
+
+from config import (
+    TEXT_CHARS, TEXT_OFFSET, AUDIO_OFFSET,
+    SPECIAL_TOKENS, NUM_SPECIAL_TOKENS, CODEC_CODEBOOK_SIZE,
+    TOTAL_VOCAB_SIZE,
+    PAD_TOKEN_ID, START_OF_TEXT_TOKEN_ID, END_OF_TEXT_TOKEN_ID,
+    START_OF_SPEECH_TOKEN_ID, END_OF_SPEECH_TOKEN_ID,
+    is_audio_token, is_special_token, is_text_token,
+)
+
+
+class TTSTokenizer:
+    def __init__(self):
+        self.char2id: dict[str, int] = {}
+        self.id2char: dict[int, str] = {}
+        for i, ch in enumerate(TEXT_CHARS):
+            tid = TEXT_OFFSET + i
+            self.char2id[ch] = tid
+            self.id2char[tid] = ch
+
+        self._special_id_to_name = {v: k for k, v in SPECIAL_TOKENS.items()}
+        self.vocab_size = TOTAL_VOCAB_SIZE
+        self.text_vocab_size = len(TEXT_CHARS)
+
+    def normalize_text(self, text: str) -> str:
+        text = re.sub(r'\s+', ' ', text).strip()
+        text = re.sub(r'[–—]', '-', text)
+        text = re.sub(r'[«»„""]', '"', text)
+        return text
+
+    def encode_text(self, text: str) -> list[int]:
+        text = self.normalize_text(text)
+        return [self.char2id[ch] for ch in text if ch in self.char2id]
+
+    def decode_text(self, ids: list[int]) -> str:
+        return "".join(self.id2char.get(t, "") for t in ids if is_text_token(t))
+
+    # ── Encoder-Decoder methods ──────────────────────────────
+
+    def build_encoder_input(self, text: str) -> torch.Tensor:
+        """
+        Encoder input: <sot> text_chars <eot>
+        No speaker token — speaker info comes from embedding.
+        """
+        text_ids = self.encode_text(text)
+        seq = [START_OF_TEXT_TOKEN_ID] + text_ids + [END_OF_TEXT_TOKEN_ID]
+        return torch.tensor(seq, dtype=torch.long)
+
+    def build_decoder_input(self, audio_codes: torch.Tensor) -> torch.Tensor:
+        """
+        Decoder input: <sos> [audio_codes + AUDIO_OFFSET] <eos>
+        audio_codes: raw MioCodec codes in [0, 12799]
+        """
+        seq = (
+            [START_OF_SPEECH_TOKEN_ID]
+            + (audio_codes + AUDIO_OFFSET).tolist()
+            + [END_OF_SPEECH_TOKEN_ID]
+        )
+        return torch.tensor(seq, dtype=torch.long)
+
+    def build_decoder_prefix(self) -> torch.Tensor:
+        """For inference: just <sos> to start generation."""
+        return torch.tensor([START_OF_SPEECH_TOKEN_ID], dtype=torch.long)
+
+    def extract_audio_codes(self, sequence: torch.Tensor) -> Optional[torch.Tensor]:
+        """Extract raw MioCodec codes from a token sequence."""
+        mask = torch.tensor([is_audio_token(t.item()) for t in sequence])
+        if not mask.any():
+            return None
+        return sequence[mask] - AUDIO_OFFSET
+
+    def describe(self, seq: torch.Tensor, max_tok: int = 30) -> str:
+        parts = []
+        for t in seq[:max_tok]:
+            tid = t.item()
+            if is_special_token(tid):
+                parts.append(self._special_id_to_name.get(tid, f"<sp_{tid}>"))
+            elif is_text_token(tid):
+                ch = self.id2char.get(tid, "?")
+                parts.append(ch if ch != " " else "·")
+            elif is_audio_token(tid):
+                code = tid - AUDIO_OFFSET
+                parts.append(f"♪{code}")
+            else:
+                parts.append(f"?{tid}")
+        r = " ".join(parts)
+        if len(seq) > max_tok:
+            r += f" ... [{len(seq) - max_tok} more]"
+        return r

BgTTS/train.py

@@ -0,0 +1,179 @@
+import os
+import glob
+import math
+import csv
+import torch
+from torch.utils.data import Dataset, DataLoader
+from torch.nn.utils.rnn import pad_sequence
+from tqdm import tqdm
+from torch.amp import autocast
+
+from config import (PAD_TOKEN_ID, START_OF_SPEECH_TOKEN_ID,
+                    END_OF_SPEECH_TOKEN_ID, AUDIO_OFFSET)
+from model import create_model, save_checkpoint
+from tokenizer import TTSTokenizer
+
+# ── Хиперпараметри ───────────────────────────────────────────────
+PEAK_LR        = 7e-5
+START_LR       = 0
+MIN_LR         = 5e-6
+WEIGHT_DECAY   = 0.01
+EPOCHS         = 20
+BATCH_SIZE     = 64
+ACCUM_STEPS    = 1              # Без accumulation
+GRAD_CLIP      = 1.0
+CKPT_EVERY     = 1000          # Checkpoint на всеки N optimizer стъпки
+LOG_FILE       = "train_log.csv"
+
+# ── Dataset ──────────────────────────────────────────────────────
+class ShardedTTSDataset(Dataset):
+    def __init__(self, data_dir):
+        self.shard_files = sorted(glob.glob(os.path.join(data_dir, "*.pt")))
+        self.samples = []
+        print(f"Зареждане на {len(self.shard_files)} шарда...")
+        for sf in self.shard_files:
+            self.samples.extend(torch.load(sf, weights_only=False))
+        print(f"Общо записи: {len(self.samples):,}")
+
+    def __len__(self):
+        return len(self.samples)
+
+    def __getitem__(self, idx):
+        item = self.samples[idx]
+        return {
+            'text_ids':    item['text_ids'].clone().detach().long(),
+            'audio_codes': item['audio_codes'].clone().detach().long(),
+            'speaker_emb': item['speaker_emb'].clone().detach().float(),
+        }
+
+def collate_fn(batch):
+    enc_ids_list, dec_ids_list, labels_list, speaker_embs = [], [], [], []
+    for item in batch:
+        enc_ids_list.append(item['text_ids'])
+        audio_codes = item['audio_codes'] + AUDIO_OFFSET
+        # GPT-style: model.py вътрешно shift-ва logits[:, :-1] vs labels[:, 1:]
+        # Затова dec_ids и labels трябва да са подравнени, а model-ът сам измества.
+        dec_ids_list.append(torch.cat([torch.tensor([START_OF_SPEECH_TOKEN_ID]), audio_codes, torch.tensor([END_OF_SPEECH_TOKEN_ID])]))
+        labels_list.append(torch.cat([torch.tensor([-100]), audio_codes, torch.tensor([END_OF_SPEECH_TOKEN_ID])]))
+        speaker_embs.append(item['speaker_emb'])
+
+    enc_ids  = pad_sequence(enc_ids_list,  batch_first=True, padding_value=PAD_TOKEN_ID)
+    dec_ids  = pad_sequence(dec_ids_list,  batch_first=True, padding_value=PAD_TOKEN_ID)
+    labels   = pad_sequence(labels_list,   batch_first=True, padding_value=-100)
+    enc_mask = (enc_ids != PAD_TOKEN_ID).long()
+    speaker_emb = torch.stack(speaker_embs)
+    return enc_ids, dec_ids, enc_mask, labels, speaker_emb
+
+# ── LR Scheduler: Warmup + Cosine Decay ─────────────────────────
+def get_lr(step: int, warmup_steps: int, total_steps: int) -> float:
+    if step < warmup_steps:
+        return START_LR + (PEAK_LR - START_LR) * (step / max(1, warmup_steps))
+    else:
+        progress = (step - warmup_steps) / max(1, total_steps - warmup_steps)
+        cosine   = 0.5 * (1.0 + math.cos(math.pi * progress))
+        return MIN_LR + (PEAK_LR - MIN_LR) * cosine
+
+# ── Основен тренировъчен цикъл ───────────────────────────────────
+def train():
+    device = "cuda" if torch.cuda.is_available() else "cpu"
+    print(f"Устройство: {device}")
+
+    processed_dir = os.path.abspath("../data/processed")
+    if not os.path.exists(processed_dir):
+        print(f"[ГРЕШКА] {processed_dir} не съществува!"); return
+
+    dataset    = ShardedTTSDataset(processed_dir)
+    dataloader = DataLoader(dataset, batch_size=BATCH_SIZE, shuffle=True,
+                            collate_fn=collate_fn, num_workers=4, pin_memory=True)
+
+    steps_per_epoch = len(dataloader) // ACCUM_STEPS  # optimizer стъпки на епоха
+    warmup_steps    = steps_per_epoch * 2            # Warmup = 2 епохи
+    total_steps     = steps_per_epoch * EPOCHS
+    print(f"Батчове/епоха: {len(dataloader):,} | Optimizer стъпки/епоха: {steps_per_epoch:,} | Accum: {ACCUM_STEPS}")
+    print(f"Warmup: {warmup_steps:,} стъпки (2 епохи) | Общо: {total_steps:,}")
+    print(f"Peak LR: {PEAK_LR}, Min LR: {MIN_LR}, Weight Decay: {WEIGHT_DECAY}, Epochs: {EPOCHS}")
+    print(f"Ефективен batch size: {BATCH_SIZE * ACCUM_STEPS}")
+
+    model     = create_model(device=device)
+    model.train()
+    optimizer = torch.optim.AdamW(model.parameters(), lr=PEAK_LR, weight_decay=WEIGHT_DECAY,
+                                   betas=(0.9, 0.999), eps=1e-8)
+    # BF16 — без GradScaler (не е нужен при bfloat16)
+
+    os.makedirs("checkpoints", exist_ok=True)
+
+    # CSV лог за реално наблюдение
+    log_path = LOG_FILE
+    log_f    = open(log_path, "w", newline="")
+    writer   = csv.writer(log_f)
+    writer.writerow(["step", "batch_loss", "avg_loss", "lr"])
+    log_f.flush()
+    print(f"Loss лог: {log_path}  (следи с: tail -f {log_path})\n")
+
+    step          = 0
+    running_loss  = 0.0
+    running_count = 0
+
+    for epoch in range(EPOCHS):
+        loop = tqdm(total=steps_per_epoch, desc=f"Епоха {epoch+1}/{EPOCHS}")
+        epoch_loss_sum, valid_batches = 0.0, 0
+
+        optimizer.zero_grad(set_to_none=True)
+        for i, (enc_ids, dec_ids, enc_mask, labels, spk_emb) in enumerate(dataloader):
+            enc_ids  = enc_ids.to(device)
+            dec_ids  = dec_ids.to(device)
+            enc_mask = enc_mask.to(device)
+            labels   = labels.to(device)
+            spk_emb  = spk_emb.to(device)
+
+            with autocast('cuda', dtype=torch.bfloat16):
+                out  = model(enc_ids=enc_ids, dec_ids=dec_ids,
+                             enc_mask=enc_mask, dec_labels=labels,
+                             speaker_emb=spk_emb)
+                loss = out['loss'] / ACCUM_STEPS
+
+            loss.backward()
+
+            batch_loss = loss.item() * ACCUM_STEPS  # реалният loss
+            epoch_loss_sum += batch_loss
+            valid_batches  += 1
+
+            if (i + 1) % ACCUM_STEPS == 0:
+                torch.nn.utils.clip_grad_norm_(model.parameters(), GRAD_CLIP)
+                optimizer.step()
+                optimizer.zero_grad(set_to_none=True)
+                step += 1
+
+                current_lr = get_lr(step, warmup_steps, total_steps)
+                for pg in optimizer.param_groups:
+                    pg['lr'] = current_lr
+
+                running_loss  += batch_loss
+                running_count += 1
+                avg_loss = running_loss / running_count
+
+                writer.writerow([step, f"{batch_loss:.4f}", f"{avg_loss:.4f}", f"{current_lr:.2e}"])
+                log_f.flush()
+
+                loop.update(1)
+                loop.set_postfix(step=step, loss=f"{batch_loss:.4f}",
+                                 avg=f"{avg_loss:.4f}", lr=f"{current_lr:.2e}")
+
+                if step % CKPT_EVERY == 0:
+                    ckpt_dir = f"checkpoints/step_{step:06d}"
+                    save_checkpoint(model, optimizer, None, step,
+                                    avg_loss, ckpt_dir, best_val_loss=None)
+                    tqdm.write(f"  ✓ Checkpoint запазен: {ckpt_dir} | step={step} | avg_loss={avg_loss:.4f}")
+
+        loop.close()
+        epoch_avg = epoch_loss_sum / max(1, valid_batches)
+        ckpt_dir  = f"checkpoints/epoch_{epoch+1}_final"
+        save_checkpoint(model, optimizer, None, step, epoch_avg, ckpt_dir, best_val_loss=None)
+        print(f"\n✓ Епоха {epoch+1} завърши. Средна загуба: {epoch_avg:.4f}")
+        print(f"  Checkpoint: {ckpt_dir}")
+
+    log_f.close()
+    print("\n[КРАЙ] Обучението приключи успешно!")
+
+if __name__ == "__main__":
+    train()

README.md

@@ -0,0 +1,66 @@
+---
+language:
+  - bg
+license: mit
+tags:
+  - text-to-speech
+  - tts
+  - bulgarian
+  - fastapi
+pipeline_tag: text-to-speech
+---
+# Ani Voice API
+
+Завършен TTS (Text-to-Speech) пакет за български език, базиран на BgTTS и Supertonic, обвит в гъвкаво FastAPI приложение.
+
+*Проектът е създаден и разработен от **Ani-Antigravity** по идея и желание на **Наско (@beleata74)**.*
+
+## Инсталация
+
+1. Уверете се, че имате Python 3.10+
+2. Инсталирайте нужните зависимости:
+   ```bash
+   pip install -r requirements.txt
+   ```
+
+## Стартиране на API сървъра
+
+```bash
+python api.py
+```
+Сървърът ще тръгне на `http://localhost:8000`. Можете да разгледате автоматичната документация на `http://localhost:8000/docs`.
+
+## Използване
+
+### 1. Генериране на цял аудио файл
+Изпраща текст и връща завършен `.wav` файл.
+
+**Пример:**
+```bash
+curl -X POST "http://localhost:8000/api/v1/synthesize" \
+     -H "Content-Type: application/json" \
+     -d '{"text": "Здравей, свят!", "voice_style": "F5", "speed": 1.6}' \
+     --output response.wav
+```
+
+### 2. Стрийминг на аудио (NDJSON)
+Изпраща аудиото на малки парчета (chunks), докато се генерират, кодирани в base64. Полезно за дълги текстове, където искате да пускате аудиото веднага.
+
+Връща редове във формат:
+```json
+{"chunk_index": 0, "audio_base64": "UklGRiQAAABXQVZFZm10IBAAAAABAAEAQB8AAEA..."}
+```
+
+Вижте файла `client_example.py` за пример как да интегрирате API-то в Python код.
+Вижте файла `voice_pipeline.py` за пример на работещ клиент-демон (daemon), който комуникира с API-то и пуска звука в реално време!
+
+## Аудио Демонстрации
+
+В репозиторито можете да намерите няколко предварително генерирани аудио файла, за да чуете как звучи моделът:
+
+1. **`demo1_conversation.wav`**
+   - *Транскрипция:* "Здравейте! Това е тестов запис от нашия нов български TTS модел. Надявам се да ви хареса как звучи гласът ми!"
+2. **`demo2_numbers.wav`** (Демонстрира нормализацията на числа и дати)
+   - *Транскрипция:* "Днес е 15 май 2026 година. Температурата навън е 23.5 градуса, а вятърът духа със скорост 5.4 километра в час. Цената е 1500 лв. за м²."
+3. **`demo3_expressive.wav`**
+   - *Транскрипция:* "Супер! Наистина много се радвам, че всичко най-накрая работи гладко. Усилията определено си заслужаваха!"

api.py

@@ -0,0 +1,53 @@
+from fastapi import FastAPI, HTTPException
+from fastapi.responses import Response, StreamingResponse
+from pydantic import BaseModel
+import uvicorn
+
+# Импортираме tts_engine - това автоматично ще зареди моделите в паметта при стартиране!
+from tts_engine import engine
+
+app = FastAPI(title="Ani Voice API", version="1.0.0")
+
+class SynthesizeRequest(BaseModel):
+    text: str
+    voice_style: str = "F5"
+    speed: float = 1.6
+
+@app.post("/api/v1/synthesize")
+def synthesize_full_audio(request: SynthesizeRequest):
+    """
+    Генерира аудио за целия текст и го връща като един WAV файл.
+    Подходящо за кратки съобщения.
+    """
+    try:
+        audio_bytes = engine.synthesize_full(request.text, request.voice_style, request.speed)
+        if not audio_bytes:
+            raise HTTPException(status_code=400, detail="Неуспешно генериране на аудио (празен текст?).")
+            
+        return Response(content=audio_bytes, media_type="audio/wav")
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+import base64
+import json
+
+@app.post("/api/v1/synthesize/stream")
+def synthesize_stream_audio(request: SynthesizeRequest):
+    """
+    Стрийминг endpoint, който връща аудио на парчета (chunks).
+    Всеки ред е JSON обект: {"chunk_index": i, "audio_base64": "..."}
+    """
+    def generate():
+        try:
+            for i, audio_bytes in enumerate(engine.synthesize_stream(request.text, request.voice_style, request.speed)):
+                encoded = base64.b64encode(audio_bytes).decode("utf-8")
+                yield json.dumps({"chunk_index": i, "audio_base64": encoded}) + "\n"
+        except Exception as e:
+            print(f"Грешка по време на стрийминг: {e}")
+            yield json.dumps({"error": str(e)}) + "\n"
+            
+    return StreamingResponse(generate(), media_type="application/x-ndjson")
+
+if __name__ == "__main__":
+    print("Стартиране на Ani Voice API сървър на порт 8000...")
+    uvicorn.run("api:app", host="0.0.0.0", port=8000, reload=False)

client_example.py

@@ -0,0 +1,27 @@
+import requests
+
+API_URL = "http://localhost:8000/api/v1/synthesize"
+
+def synthesize_text(text: str, output_file: str):
+    """
+    Изпраща текст към API-то и запазва резултата като WAV файл.
+    """
+    print(f"Изпращане на заявка за: '{text}'...")
+    
+    response = requests.post(API_URL, json={
+        "text": text,
+        "voice_style": "F5",
+        "speed": 1.6
+    })
+    
+    if response.status_code == 200:
+        with open(output_file, "wb") as f:
+            f.write(response.content)
+        print(f"✅ Аудиото е запазено успешно в: {output_file}")
+    else:
+        print(f"❌ Грешка: {response.status_code} - {response.text}")
+
+if __name__ == "__main__":
+    text_to_say = "Здравей! Това е тестов запис, създаден чрез новото Ani Voice API."
+    output_filename = "test_api_output.wav"
+    synthesize_text(text_to_say, output_filename)

demo1_conversation.wav

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5395b9f0d2f01685b82c1592dd236999deec3de7e2a4e1a3ab25611a8f1d01d6
+size 332204

demo2_numbers.wav

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f7cdfc164606f698053e9264117e15093f4d15d0d2d7621eee131d03141a4130
+size 762284

demo3_expressive.wav

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ed299d60ff6f02ed78d7bce2322fb949e74daf0fbecfb3eae8775425943a36d7
+size 318764

normalizer.py

@@ -0,0 +1,41 @@
+import re
+from bg_text_normalizer import normalize_text as bg_norm
+
+# Допълнителни специфични замени, които bg_text_normalizer изпуска
+EXTRA_ABBREVIATIONS = {
+    r"\bм²\b": "квадратен метър",
+    r"\bкв\.м\.\b": "квадратен метър",
+    r"\bт\.е\.\b": "тоест",
+}
+
+def normalize_text(text: str) -> str:
+    """
+    Нормализира текста, използвайки bg-text-normalizer + наши специфични правила.
+    """
+    # 0.5 Предварителна обработка на десетични дроби: заменяме точката със запетая
+    # bg-text-normalizer бърка '1.4' с '1 април'. За да го чете като дроб, му трябва запетая '1,4'.
+    text = re.sub(r'(\d)\.(\d)', r'\1,\2', text)
+    
+    # 1. Първо прилагаме библиотеката bg_text_normalizer
+    text = bg_norm(text)
+    
+    # 2. Оправяме точките след съкращения като "лв." и "гр.", които библиотеката е превърнала в "лева."
+    text = text.replace("лева.", "лева")
+    text = text.replace("стотинки.", "стотинки")
+    
+    # 3. Прилагаме нашите допълнителни правила
+    for pattern, replacement in EXTRA_ABBREVIATIONS.items():
+        text = re.sub(pattern, replacement, text, flags=re.IGNORECASE)
+        
+    # Допълнително хващаме м² (без \b, защото ² не е дума)
+    text = text.replace("м²", "квадратен метър")
+    
+    # Махане на двойни интервали
+    text = re.sub(r"\s+", " ", text).strip()
+    
+    return text
+
+if __name__ == "__main__":
+    test_text = "Цената е 1500 лв. за м² в кв. Лозенец."
+    print("Original:", test_text)
+    print("Normalized:", normalize_text(test_text))

requirements.txt

@@ -0,0 +1,11 @@
+torch==2.13.0.dev20260603+cu132
+torchaudio==2.11.0.dev20260608+cu132
+torchvision==0.28.0.dev20260608+cu132
+numpy<2.0.0
+supertonic==1.3.1
+bg-text-normalizer==1.1.0
+num2cyrillic==1.0.0
+fastapi>=0.110.0
+uvicorn>=0.29.0
+pydantic>=2.7.0
+requests>=2.31.0

tts_engine.py

@@ -0,0 +1,157 @@
+import os
+import io
+import re
+import wave
+import torch
+import numpy as np
+import tempfile
+import sys
+import supertonic
+
+# Добавяме BgTTS към sys.path, за да може вътрешните му импорти да работят
+sys.path.append(os.path.join(os.path.dirname(__file__), 'BgTTS'))
+from inference import synthesize
+from normalizer import normalize_text
+
+class TTSEngine:
+    def __init__(self):
+        self.device = "cuda" if torch.cuda.is_available() else "cpu"
+        print(f"Зареждам TTS Engine на устройство: {self.device}")
+        
+        # Supertonic (Референтно аудио)
+        from supertonic import TTS
+        self.engine = TTS(auto_download=True)
+        
+        # BgTTS (Основен модел)
+        self.bgtts_checkpoint = os.path.join(os.path.dirname(__file__), "BgTTS", "checkpoint_inference.pt")
+        # BgTTS inference.synthesize зарежда модела всеки път, ако не му подадем модела. 
+        # В текущия BgTTS/inference.py synthesize() вика load_for_inference(), ако се подаде път.
+        # За сега ще ползваме пътя, тъй като така е написан BgTTS. 
+        # Ако искаме пълно кеширане, може да се наложи леко пренаписване на BgTTS/inference.py.
+        # Но засега ще ползваме оригиналната synthesize функция.
+        
+        print("TTS Engine зареден успешно.")
+
+    def split_text_for_tts(self, text: str) -> list[str]:
+        text = text.strip()
+        if not text:
+            return []
+        raw = re.split(r'(?<=[\.\!\?…])\s+|\n+', text)
+        chunks = []
+        buf = ""
+        for part in raw:
+            part = part.strip()
+            if not part: continue
+            
+            if not buf or len(buf) < 80 or len(buf) + len(part) + 1 <= 200:
+                buf = (buf + " " + part).strip()
+            else:
+                chunks.append(buf)
+                buf = part
+        if buf: chunks.append(buf)
+        return chunks
+
+    def generate_chunk(self, chunk_text: str, voice_style: str = "F5", speed: float = 1.6) -> bytes:
+        """
+        Генерира аудио за едно изречение (chunk) и го връща като WAV байтове.
+        """
+        clean_text = chunk_text.replace('"', '').replace('„', '').replace('“', '') \
+                               .replace("’", "'").replace("–", "-").replace("—", "-") \
+                               .replace("*", "")
+                               
+        if not clean_text.strip():
+            return b""
+            
+        # 1. Генериране на референтно аудио
+        # Ако voice_style е стринг (напр. "F5"), взимаме съответния обект
+        if isinstance(voice_style, str):
+            v_style = self.engine.get_voice_style(voice_name=voice_style)
+        else:
+            v_style = voice_style
+            
+        wav_array, _ = self.engine.synthesize(clean_text, voice_style=v_style, lang="bg", speed=speed)
+        wav_data = np.asarray(wav_array).flatten()
+        wav_max = np.max(np.abs(wav_data))
+        if wav_max > 0:
+            wav_data = wav_data / wav_max
+        pcm_data = (wav_data * 32767).astype(np.int16)
+        
+        # Записваме временно референтното аудио (тъй като BgTTS изисква файл)
+        fd, ref_path = tempfile.mkstemp(suffix=".wav")
+        os.close(fd)
+        with wave.open(ref_path, "wb") as wf:
+            wf.setnchannels(1)
+            wf.setsampwidth(2)
+            wf.setframerate(44100)
+            wf.writeframes(pcm_data.tobytes())
+            
+        # 2. Генериране на крайното аудио
+        fd, final_path = tempfile.mkstemp(suffix=".wav")
+        os.close(fd)
+        
+        try:
+            synthesize(checkpoint=self.bgtts_checkpoint, 
+                       text=clean_text, 
+                       output=final_path, 
+                       speaker_wav=ref_path,
+                       device=self.device)
+                       
+            # Прочитане на резултата
+            with open(final_path, "rb") as f:
+                audio_bytes = f.read()
+                
+            return audio_bytes
+            
+        finally:
+            try:
+                os.remove(ref_path)
+                os.remove(final_path)
+            except OSError:
+                pass
+
+    def synthesize_stream(self, text: str, voice_style: str = "F5", speed: float = 1.6):
+        """
+        Генератор, който нормализира текста, цепи го на парчета и връща WAV байтове за всяко парче.
+        """
+        normalized_text = normalize_text(text)
+        chunks = self.split_text_for_tts(normalized_text)
+        
+        for chunk in chunks:
+            audio_bytes = self.generate_chunk(chunk, voice_style, speed)
+            if audio_bytes:
+                yield audio_bytes
+
+    def synthesize_full(self, text: str, voice_style: str = "F5", speed: float = 1.6) -> bytes:
+        """
+        Нормализира текста, цепи го, генерира всички парчета и ги слепва в един общ WAV файл.
+        """
+        normalized_text = normalize_text(text)
+        chunks = self.split_text_for_tts(normalized_text)
+        
+        all_frames = b""
+        params = None
+        
+        for chunk in chunks:
+            audio_bytes = self.generate_chunk(chunk, voice_style, speed)
+            if not audio_bytes:
+                continue
+                
+            # Парсване на WAV данните, за да можем да ги слеем без да дублираме хедъри
+            with wave.open(io.BytesIO(audio_bytes), "rb") as wf:
+                if not params:
+                    params = wf.getparams()
+                all_frames += wf.readframes(wf.getnframes())
+                
+        if not params:
+            return b""
+            
+        # Създаване на крайния WAV
+        out_io = io.BytesIO()
+        with wave.open(out_io, "wb") as wf:
+            wf.setparams(params)
+            wf.writeframes(all_frames)
+            
+        return out_io.getvalue()
+
+# Глобална инстанция за по-лесно преизползване
+engine = TTSEngine()

voice_pipeline.py

@@ -0,0 +1,108 @@
+import os
+import time
+import json
+import base64
+import requests
+import tempfile
+import threading
+import queue
+import winsound
+
+TRANSCRIPT_PATH = r"C:\Users\nasko\.gemini\antigravity\brain\695897cf-1c58-4886-a686-e9d8c406ebef\.system_generated\logs\transcript.jsonl"
+API_URL = "http://localhost:8000/api/v1/synthesize/stream"
+
+audio_queue = queue.Queue()
+
+def player_worker():
+    """
+    Взима готови WAV файлове от опашката и ги пуска.
+    """
+    while True:
+        file_path = audio_queue.get()
+        if file_path is None: break
+        
+        print(f"🔊 Възпроизвеждам от API...")
+        winsound.PlaySound(file_path, winsound.SND_FILENAME)
+        
+        try:
+            os.remove(file_path)
+        except OSError:
+            pass
+            
+        audio_queue.task_done()
+
+def process_text(text: str):
+    """
+    Изпраща текста към API-то и чака за стрийминг на аудио парчета.
+    """
+    print(f"📡 Изпращане към API: {text[:50]}...")
+    try:
+        response = requests.post(API_URL, json={
+            "text": text,
+            "voice_style": "F5",
+            "speed": 1.6
+        }, stream=True)
+        
+        if response.status_code != 200:
+            print(f"Грешка от API: {response.status_code} - {response.text}")
+            return
+            
+        for line in response.iter_lines():
+            if line:
+                data = json.loads(line)
+                if "error" in data:
+                    print(f"API Грешка: {data['error']}")
+                    continue
+                    
+                chunk_index = data.get("chunk_index")
+                audio_base64 = data.get("audio_base64")
+                
+                if audio_base64:
+                    audio_bytes = base64.b64decode(audio_base64)
+                    
+                    # Записваме временно файла и го пускаме в опашката
+                    fd, file_path = tempfile.mkstemp(suffix=f"_chunk_{chunk_index}.wav")
+                    os.close(fd)
+                    
+                    with open(file_path, "wb") as f:
+                        f.write(audio_bytes)
+                        
+                    audio_queue.put(file_path)
+    except requests.exceptions.ConnectionError:
+        print("Не мога да се свържа с API-то! Увери се, че `api.py` работи на порт 8000.")
+    except Exception as e:
+        print(f"Грешка при комуникация с API: {e}")
+
+def tail_file():
+    """
+    Следи чата (transcript.jsonl) за нови съобщения от модела.
+    """
+    if not os.path.exists(TRANSCRIPT_PATH):
+        print(f"Файлът не съществува: {TRANSCRIPT_PATH}")
+        return
+        
+    with open(TRANSCRIPT_PATH, "r", encoding="utf-8") as f:
+        f.seek(0, 2) 
+        
+        while True:
+            line = f.readline()
+            if not line:
+                time.sleep(0.5)
+                continue
+            
+            try:
+                data = json.loads(line)
+                if data.get("source") == "MODEL" and data.get("type") in ["PLANNER_RESPONSE", "GENERIC"]:
+                    full_text = data.get("content", "")
+                    if full_text and not full_text.startswith("Created At:"):
+                        print("\n📝 Получен нов текст от чата.")
+                        process_text(full_text)
+            except Exception as e:
+                pass
+
+if __name__ == "__main__":
+    t_play = threading.Thread(target=player_worker, daemon=True)
+    t_play.start()
+    
+    print("Ani Voice Client слуша за съобщения и чака API-то...")
+    tail_file()