# Сравнение TTS-движков

Сравните ведущие открытые движки преобразования текста в речь для развертывания на GPU-серверах Clore.ai.

{% hint style="info" %}
**Преобразование текста в речь (TTS)** преобразует написанный текст в звучащую естественно аудиозапись. Это руководство сравнивает пять ведущих открытых TTS-движков: XTTS v2, Bark, Kokoro, Fish Speech и MeloTTS — охватывая качество, скорость, поддержку языков и возможности клонирования голоса.
{% endhint %}

***

## Краткая матрица принятия решений

|                         | XTTS v2               | Bark               | Kokoro               | Fish Speech       | MeloTTS              |
| ----------------------- | --------------------- | ------------------ | -------------------- | ----------------- | -------------------- |
| **Разработчик**         | Coqui AI              | Suno AI            | Hexgrad              | Fish Audio        | MyShell AI           |
| **Качество**            | ⭐⭐⭐⭐⭐                 | ⭐⭐⭐⭐               | ⭐⭐⭐⭐                 | ⭐⭐⭐⭐⭐             | ⭐⭐⭐                  |
| **Скорость**            | Средне                | Медленно           | **Быстро**           | **Быстро**        | **Самый быстрый**    |
| **Клонирование голоса** | ✅ (фрагмент 3 с)      | ✅ (пресеты голоса) | ✅ (ограниченно)      | ✅ (фрагмент 10 с) | ❌                    |
| **Языки**               | 17                    | 10+                | Английский           | 8+                | 8                    |
| **Мин. VRAM**           | 4 ГБ                  | 8 ГБ               | **Подходит для CPU** | 4 ГБ              | **Подходит для CPU** |
| **Лицензия**            | CPML (некоммерческое) | MIT                | Apache 2.0           | CC BY-NC-SA       | MIT                  |
| **Звезды на GitHub**    | 35K+ (Coqui TTS)      | 38K+               | 12K+                 | 14K+              | 15K+                 |

***

## Обзор

### XTTS v2

XTTS v2 от Coqui — эталон открытого клонирования голоса в TTS. Он может клонировать любой голос по 3-секундному аудиофрагменту с исключительной точностью.

**Философия**: Максимальная выразительность и качество клонирования голоса.

```python
from TTS.api import TTS

tts = TTS("tts_models/multilingual/multi-dataset/xtts_v2").to("cuda")

# Клонирование голоса в режиме zero-shot по 3-секундной ссылке
tts.tts_to_file(
    text="Hello, this is a cloned voice speaking naturally.",
    speaker_wav="reference_voice.wav",
    language="en",
    file_path="output.wav"
)
```

### Bark

Bark от Suno — это TTS-модель на основе трансформера, генерирующая крайне выразительную речь, включая несрочные звуки: смех, вздохи, музыку и звуковые эффекты.

**Философия**: Не только речь — полная генерация аудио.

```python
from bark import SAMPLE_RATE, generate_audio, preload_models
from scipy.io.wavfile import write as write_wav

preload_models()

audio_array = generate_audio(
    "[laughs] Hello! [clears throat] This is Bark TTS. [sighs]"
)
write_wav("output.wav", SAMPLE_RATE, audio_array)
```

### Kokoro

Kokoro — лёгкая, быстрая TTS-модель, оптимизированная для английского. Несмотря на небольшой размер (\~82M параметров), она обеспечивает удивительно высокое качество.

**Философия**: Маленькая модель, большое качество, работает где угодно.

```python
from kokoro import KPipeline
import soundfile as sf

pipeline = KPipeline(lang_code='a')  # 'a' = американский английский

generator = pipeline(
    "The quick brown fox jumps over the lazy dog.",
    voice='af_heart',  # предустановленный голос
    speed=1.0,
)

for _, _, audio in generator:
    sf.write('output.wav', audio, 24000)
```

### Fish Speech

Fish Speech от Fish Audio — TTS производственного уровня с исключительным клонированием голоса по коротким фрагментам. Использует новую архитектуру кодека + языковой модели.

**Философия**: Качество производства, быстрая генерация, отличное клонирование.

```python
# Fish Speech через HTTP API
import requests

response = requests.post(
    "http://localhost:8080/v1/tts",
    json={
        "text": "Hello, this is Fish Speech generating audio.",
        "reference_id": "your-voice-id",
        "format": "wav",
    }
)

with open("output.wav", "wb") as f:
    f.write(response.content)
```

### MeloTTS

MeloTTS от MyShell — ультрабыстрый мультиакцентный TTS, оптимизированный для приложений в реальном времени. Эффективно работает на CPU и поддерживает несколько англоязычных акцентов и азиатские языки.

**Философия**: Скорость в реальном времени на любом масштабе.

```python
from melo.api import TTS

speed = 1.0
device = 'auto'

model = TTS(language='EN', device=device)
speaker_ids = model.hps.data.spk2id

output_path = 'output.wav'
model.tts_to_file(
    "Hello world! MeloTTS is very fast.",
    speaker_ids['EN-Default'],
    output_path,
    speed=speed
)
```

***

## Сравнение качества

### Оценки естественности (MOS — Mean Opinion Score, 1-5)

{% hint style="info" %}
Значения MOS являются приблизительными и основаны на опубликованных статьях и оценках сообщества. Фактическое качество сильно зависит от содержания текста и конфигурации голоса.
{% endhint %}

| Модель      | MOS для английского | MOS для многоязычных моделей | Выразительность   |
| ----------- | ------------------- | ---------------------------- | ----------------- |
| XTTS v2     | 4.3                 | 4.1                          | ⭐⭐⭐⭐⭐             |
| Bark        | 3.9                 | 3.7                          | ⭐⭐⭐⭐⭐ (уникально) |
| Kokoro      | 4.2                 | Н/Д (только EN)              | ⭐⭐⭐               |
| Fish Speech | 4.4                 | 4.2                          | ⭐⭐⭐⭐              |
| MeloTTS     | 3.8                 | 3.6                          | ⭐⭐                |

### Что каждая модель выполняет лучше всего

| Модель      | Выделяющаяся особенность качества                            |
| ----------- | ------------------------------------------------------------ |
| XTTS v2     | Почти идеальное клонирование голоса, эмоциональный диапазон  |
| Bark        | Несрочные звуки, смех, музыка, эффекты                       |
| Kokoro      | Лучшее соотношение качества и размера, естественный ритм     |
| Fish Speech | Лучшее общее ощущение естественности + точность клонирования |
| MeloTTS     | Последовательный, чистый вывод для длинных текстов           |

***

## Бенчмарки скорости

### Символов в секунду (CPU vs GPU)

Тест: "The quick brown fox jumps over the lazy dog. How are you today?" (60 символов)

| Модель      | Скорость на CPU      | Скорость на GPU (RTX 3080) | Фактор реального времени |
| ----------- | -------------------- | -------------------------- | ------------------------ |
| XTTS v2     | \~15 символов/с      | \~150 символов/с           | 0.3× (GPU)               |
| Bark        | \~5 символов/с       | \~40 символов/с            | 0.1× (GPU)               |
| Kokoro      | \~200 символов/с     | \~800 символов/с           | **5× (GPU)**             |
| Fish Speech | \~80 символов/с      | \~500 символов/с           | **3× (GPU)**             |
| MeloTTS     | **\~500 символов/с** | \~2000 символов/с          | **12× (GPU)**            |

*Фактор реального времени > 1.0 означает быстрее скорости воспроизведения*

### Время генерации 1 минуты аудио

| Модель      | CPU       | RTX 3080  | A100     |
| ----------- | --------- | --------- | -------- |
| XTTS v2     | \~8 мин   | \~30 с    | \~10 с   |
| Bark        | \~20 мин  | \~3 мин   | \~45 с   |
| Kokoro      | \~20 с    | \~5 с     | \~2 с    |
| Fish Speech | \~45 с    | \~8 с     | \~3 с    |
| MeloTTS     | **\~8 с** | **\~2 с** | **<1 с** |

{% hint style="success" %}
**Для приложений в реальном времени**: MeloTTS и Kokoro — явные победители. Обе могут генерировать речь быстрее воспроизведения даже на CPU.
{% endhint %}

***

## Поддержка языков

### Поддерживаемые языки

| Модель      | Языки | Примечательно                                                      |
| ----------- | ----- | ------------------------------------------------------------------ |
| XTTS v2     | 17    | EN, ES, FR, DE, IT, PT, PL, TR, RU, NL, CS, AR, ZH, JA, HU, KO, HI |
| Bark        | 10+   | EN, ZH, FR, DE, HI, IT, JA, KO, PL, PT, RU, ES, TR                 |
| Kokoro      | 2     | Английский (US/UK), японский (ограниченно)                         |
| Fish Speech | 8     | EN, ZH, JA, KO, FR, DE, AR, ES                                     |
| MeloTTS     | 8     | EN (4 акцента), ES, FR, ZH, JA, KO                                 |

### Примечания по качеству языка

| Модель      | Английский | Китайский         | Японский          | Европейский |
| ----------- | ---------- | ----------------- | ----------------- | ----------- |
| XTTS v2     | Отлично    | Хорошо            | Хорошо            | Отлично     |
| Bark        | Хорошо     | Удовлетворительно | Удовлетворительно | Хорошо      |
| Kokoro      | Отлично    | ❌                 | Ограничено        | ❌           |
| Fish Speech | Отлично    | **Лучший выбор**  | Хорошо            | Хорошо      |
| MeloTTS     | Хорошо     | Хорошо            | Хорошо            | Хорошо      |

{% hint style="info" %}
**Для китайского TTS**: Fish Speech и MeloTTS — лучшие открытые варианты. Обе модели естественно обрабатывают тоны и иероглифы.

**Для многоязычных приложений**: XTTS v2 поддерживает наибольшее количество языков с последовательным качеством во всех из них.
{% endhint %}

***

## Сравнение клонирования голоса

### Возможности клонирования

| Модель      | Длина референса       | Качество клонирования | Zero-shot |
| ----------- | --------------------- | --------------------- | --------- |
| XTTS v2     | **3 секунды**         | ⭐⭐⭐⭐⭐                 | ✅         |
| Bark        | Только пресеты голоса | ⭐⭐⭐                   | Частично  |
| Kokoro      | Не поддерживается     | ❌                     | ❌         |
| Fish Speech | 10 секунд             | ⭐⭐⭐⭐⭐                 | ✅         |
| MeloTTS     | Не поддерживается     | ❌                     | ❌         |

### Клонирование голоса XTTS v2

```python
from TTS.api import TTS
import torch

# Загрузите модель
tts = TTS("tts_models/multilingual/multi-dataset/xtts_v2")
tts.to("cuda" if torch.cuda.is_available() else "cpu")

# Клонировать голос из референса (минимум 3 секунды, желательно 10–30 секунд)
tts.tts_to_file(
    text="""
    Welcome to our podcast. Today we're discussing the future of AI 
    and its impact on society. I'm your host, and I'm excited to 
    share some fascinating insights with you.
    """,
    speaker_wav="speaker_sample.wav",  # Ваш референсный аудиофайл
    language="en",
    file_path="cloned_voice_output.wav"
)
```

### Клонирование голоса Fish Speech

```bash
# Клонирование из референсного аудио
fish_speech_cli tts \
  --text "This is my cloned voice speaking a new sentence." \
  --reference-audio speaker_sample.wav \
  --reference-text "The original text spoken in the reference audio." \
  --output cloned_output.wav
```

### Пресеты голосов Bark

```python
from bark import generate_audio, SAMPLE_RATE
from scipy.io.wavfile import write

# Bark использует предопределённые коды говорящих
voice_presets = {
    "male_US": "v2/en_speaker_6",
    "female_US": "v2/en_speaker_9",
    "male_UK": "v2/en_speaker_0",
    "announcer": "v2/en_speaker_2",
}

audio = generate_audio(
    "Welcome! [laughs] This is absolutely fascinating technology.",
    history_prompt=voice_presets["female_US"]
)
write("bark_output.wav", SAMPLE_RATE, audio)
```

***

## XTTS v2: Подробно

### Архитектура

* **VITS + GPT** гибридная архитектура
* Обучена на 16K+ часах по 17 языкам
* Минимум 3 секунды для zero-shot клонирования

### Установка на Clore.ai

```bash
pip install TTS
# Версия для GPU
pip install TTS[all]
```

### Развёртывание в Docker

```dockerfile
FROM nvidia/cuda:12.1.0-cudnn8-runtime-ubuntu22.04

RUN apt-get update && apt-get install -y python3 python3-pip git ffmpeg
RUN pip3 install TTS fastapi uvicorn

WORKDIR /app
COPY server.py .

EXPOSE 5002
CMD ["uvicorn", "server:app", "--host", "0.0.0.0", "--port", "5002"]
```

```python
# server.py — XTTS v2 REST API
from fastapi import FastAPI, UploadFile, Form
from fastapi.responses import FileResponse
from TTS.api import TTS
import tempfile, os

app = FastAPI()
tts = TTS("tts_models/multilingual/multi-dataset/xtts_v2").to("cuda")

@app.post("/tts")
async def synthesize(
    text: str = Form(...),
    language: str = Form("en"),
    speaker_file: UploadFile = None
):
    with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as out:
        output_path = out.name

    speaker_path = None
    if speaker_file:
        with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as ref:
            ref.write(await speaker_file.read())
            speaker_path = ref.name

    tts.tts_to_file(
        text=text,
        speaker_wav=speaker_path,
        language=language,
        file_path=output_path
    )
    return FileResponse(output_path, media_type="audio/wav")
```

```bash
docker build -t xtts-server .
docker run -d --gpus all -p 5002:5002 xtts-server
```

**Слабые стороны**: Лицензия CPML (некоммерческая без разрешения), медленнее, чем Kokoro/MeloTTS

***

## Bark: Подробно

### Архитектура

* **Трансформер в стиле GPT** для генерации аудиотокенов
* Трёхэтапный процесс: текст → семантика → грубые → тонкие токены
* Генерирует реальные аудиокодек-токены (EnCodec)

### Что делает Bark уникальным

Bark — единственный открытый TTS, который нативно генерирует:

* 🎵 Фоновую музыку внутри речи
* 😂 Смех, вздохи, прочищание горла
* 🎭 Несколько говорящих в одной генерации
* 🌍 Выступления на смешанных языках

### Язык разметки

```python
from bark import generate_audio, SAMPLE_RATE
from scipy.io.wavfile import write

# Специальные токены для выразительности
text = """
[clears throat] Good morning everyone. [laughs] 
Today's presentation will cover... 
[sighs deeply] ...actually quite a lot of ground.
[music: upbeat jazz] Let's get started!
"""

audio = generate_audio(text, history_prompt="v2/en_speaker_6")
write("output.wav", SAMPLE_RATE, audio)
```

### Установка

```bash
pip install git+https://github.com/suno-ai/bark.git
```

**Слабые стороны**: Медленно (трёхступенчатый конвейер), непоследовательно между запусками, нет истинного клонирования голоса

***

## Kokoro: Подробно

### Архитектура

* **82M параметров** Модель на основе StyleTTS2
* Чрезвычайно малая, но с удивительно высоким качеством
* Быстрая генерация на CPU и GPU

### Доступные голоса

```python
from kokoro import KPipeline

pipeline = KPipeline(lang_code='a')  # 'a' = американский английский, 'b' = британский

# Доступные голоса
voices = {
    'af_heart': 'American Female (warm)',
    'af_bella': 'American Female (bella)',
    'af_nicole': 'American Female (nicole)',
    'am_michael': 'American Male (michael)',
    'am_fenrir': 'American Male (fenrir)',
    'bf_emma': 'British Female (emma)',
    'bm_george': 'British Male (george)',
}

# Генерация с разными голосами
for voice_name, description in voices.items():
    gen = pipeline("Hello, this is a test.", voice=voice_name)
    for _, _, audio in gen:
        print(f"Generated with {description}")
```

### Поддержка стриминга

```python
import sounddevice as sd
from kokoro import KPipeline

pipeline = KPipeline(lang_code='a')

# Воспроизводить аудио в реальном времени по мере генерации
text = "This is a very long text that will be streamed as it generates, providing low-latency audio output."

for _, _, audio in pipeline(text, voice='af_heart'):
    sd.play(audio, samplerate=24000)
    sd.wait()
```

**Слабые стороны**: Только английский (в основном), нет клонирования голоса, ограниченная выразительность

***

## Fish Speech: Подробно

### Архитектура

* **VQGAN + языковая модель** архитектура
* Обучена на 700K+ часах аудио
* Сильная многоязычность с поддержкой азиатских языков

### Установка

```bash
pip install fish-speech

# Или через Docker
docker run -d \
  --gpus all \
  -p 8080:8080 \
  fishaudio/fish-speech:latest \
  +api_server.workers_count=1
```

### Python API

```python
import httpx
import base64

# Через HTTP API
with httpx.Client() as client:
    response = client.post(
        "http://localhost:8080/v1/tts",
        json={
            "text": "Hello from Fish Speech! This sounds very natural.",
            "format": "wav",
            "mp3_bitrate": 128,
            "normalize": True,
        }
    )
    
    with open("fish_output.wav", "wb") as f:
        f.write(response.content)
```

### Клонирование голоса

```python
# Загрузите референс, получите ID голоса
with open("my_voice.wav", "rb") as f:
    response = httpx.post(
        "http://localhost:8080/v1/voices",
        files={"file": f},
        data={"text": "The text spoken in this recording."}
    )
    voice_id = response.json()["id"]

# Использовать клонированный голос
response = httpx.post(
    "http://localhost:8080/v1/tts",
    json={
        "text": "Now speaking in the cloned voice.",
        "reference_id": voice_id,
    }
)
```

**Слабые стороны**: Лицензия CC BY-NC-SA (некоммерческая), требуется больше VRAM для лучшего качества

***

## MeloTTS: Подробно

### Архитектура

* **Основано на VITS2** архитектура
* Обучение на английских акцентах
* Сильно оптимизировано для скорости вывода

### Акценты и языки

```python
from melo.api import TTS

# Поддерживаемые коды языков и акцентов
configs = {
    'EN':    ['EN-Default', 'EN-US', 'EN-BR', 'EN-INDIA', 'EN-AU'],
    'ES':    ['ES'],
    'FR':    ['FR'],
    'ZH':    ['ZH'],
    'JP':    ['JP'],
    'KR':    ['KR'],
}

model = TTS(language='EN', device='cuda')
speaker_ids = model.hps.data.spk2id

# Сгенерировать с британским акцентом
model.tts_to_file(
    "Cheerio! Fancy a spot of tea?",
    speaker_ids['EN-BR'],
    'british.wav'
)

# Сгенерировать с индийским акцентом
model.tts_to_file(
    "Namaste! Welcome to our company.",
    speaker_ids['EN-INDIA'],
    'indian.wav'
)
```

### Пакетная обработка (очень быстро)

```python
from melo.api import TTS
import time

model = TTS(language='EN', device='cuda')
sid = model.hps.data.spk2id['EN-Default']

texts = [
    "Первое предложение для синтеза.",
    "Второе предложение здесь.",
    "Третье и последнее предложение.",
]

start = time.time()
for i, text in enumerate(texts):
    model.tts_to_file(text, sid, f'output_{i}.wav')
elapsed = time.time() - start
print(f"Generated {len(texts)} files in {elapsed:.2f}s")
```

**Слабые стороны**: Нет клонирования голоса, роботизированный звук на высокой скорости, ограниченная выразительность

***

## Развертывание на Clore.ai

### Универсальный TTS-сервер

```yaml
# docker-compose.yml — TTS-сервис с несколькими бэкендами
version: "3.8"

services:
  xtts:
    build:
      context: ./xtts
    ports:
      - "5002:5002"
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: 1
              capabilities: [gpu]
    volumes:
      - ./voices:/app/voices

  kokoro:
    image: ghcr.io/remsky/kokoro-fastapi-cpu:latest
    ports:
      - "8880:8880"
    # GPU не требуется!

  fish-speech:
    image: fishaudio/fish-speech:latest
    ports:
      - "8080:8080"
    command: +api_server.workers_count=2
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: 1
              capabilities: [gpu]
```

### Краткое резюме требований VRAM

| Модель      | CPU              | GPU 4GB | GPU 8GB | GPU 16GB |
| ----------- | ---------------- | ------- | ------- | -------- |
| XTTS v2     | Медленно         | ✅       | ✅       | ✅        |
| Bark        | Очень медленно   | ❌       | ✅       | ✅        |
| Kokoro      | **Быстро**       | ✅       | ✅       | ✅        |
| Fish Speech | Средне           | ✅       | ✅       | ✅        |
| MeloTTS     | **Очень быстро** | ✅       | ✅       | ✅        |

***

## Примеры интеграции

### OpenAI-совместимое API (для замены без изменений)

```python
# Многие TTS-серверы предлагают OpenAI-совместимые эндпоинты
# Используйте Kokoro FastAPI или аналогичный

from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:8880/v1",  # Ваш TTS-сервер
    api_key="not-needed"
)

response = client.audio.speech.create(
    model="kokoro",
    voice="af_heart",
    input="Hello world! This uses the OpenAI TTS API format.",
)
response.stream_to_file("output.mp3")
```

### Интеграция с LangChain

```python
# Использование TTS с LangChain для голосовых агентов
from langchain_community.tools import Tool
from TTS.api import TTS

tts = TTS("tts_models/multilingual/multi-dataset/xtts_v2").to("cuda")

def speak(text: str) -> str:
    tts.tts_to_file(text=text, language="en", file_path="/tmp/response.wav")
    return "/tmp/response.wav"

tts_tool = Tool(
    name="text_to_speech",
    func=speak,
    description="Преобразовать текст в аудиофайл речи"
)
```

***

## Когда что использовать

### Руководство по принятию решений

```
Нужно клонирование голоса по короткому фрагменту?
  → XTTS v2 (референс 3 с) или Fish Speech (референс 10 с)

Нужна генерация в реальном времени/самая быстрая?
  → MeloTTS (дружелюбен к CPU) или Kokoro

Нужна выразительная речь (смех, эмоции)?
  → Bark (уникальные несрочные звуки) или XTTS v2

Нужны китайский/японский/корейский?
  → Fish Speech (лучшее для CJK) или MeloTTS

Только английский, максимальное качество?
  → Kokoro (лучшее соотношение размера/качества)

Нужны 17+ языков?
  → XTTS v2

Разрешено коммерческое использование?
  → Kokoro (Apache) или MeloTTS (MIT) или Bark (MIT)

Некомерческие исследования?
  → Любой (XTTS v2 CPML или Fish Speech CC BY-NC-SA)
```

### По типу приложения

| Приложение                | Лучший выбор            | Почему                              |
| ------------------------- | ----------------------- | ----------------------------------- |
| Генерация аудиокниг       | XTTS v2                 | Натуральный, согласованный голос    |
| Чатбот в реальном времени | MeloTTS или Kokoro      | Самая быстрая инференция            |
| Автоматизация подкастов   | XTTS v2 или Fish Speech | Лучшее клонирование                 |
| Персонажи игр             | Bark                    | Экспрессивные, разнообразные голоса |
| Служба поддержки клиентов | MeloTTS                 | Масштабируемо, быстро               |
| Инструменты доступности   | Kokoro                  | Легковесно, бесплатно               |
| Даббинг голоса            | Fish Speech             | Лучшее качество клонирования        |
| Длинное повествование     | XTTS v2                 | Постоянное качество                 |

***

## Краткое изложение лицензий

{% hint style="warning" %}
**Лицензия важна для коммерческого использования!** Всегда проверяйте перед развёртыванием в продакшене.
{% endhint %}

| Модель      | Лицензия                   | Коммерческое? | Примечания                                         |
| ----------- | -------------------------- | ------------- | -------------------------------------------------- |
| XTTS v2     | Coqui Public Model License | ❌ Бесплатно   | Требуется лицензия для коммерческого использования |
| Bark        | MIT                        | ✅             | Бесплатно для любого использования                 |
| Kokoro      | Apache 2.0                 | ✅             | Бесплатно для любого использования                 |
| Fish Speech | CC BY-NC-SA 4.0            | ❌             | Только некоммерческое использование                |
| MeloTTS     | MIT                        | ✅             | Бесплатно для любого использования                 |

**Полностью открыто для коммерческого использования**: Bark, Kokoro, MeloTTS

***

## Стоимость на Clore.ai

```
Kokoro/MeloTTS (CPU или недорогая GPU):
  Самый дешёвый сервер ~0,05$/ч → ~36$/мес
  Может обрабатывать 100+ одновременных запросов на CPU

XTTS v2 (RTX 3080):
  ~0,30$/ч → ~220$/мес
  Ёмкость ~500 запросов/ч

Fish Speech (RTX 4090):
  ~0,60$/ч → ~440$/мес  
  Ёмкость ~1000 запросов/ч
```

***

## Полезные ссылки

* [Coqui TTS (XTTS)](https://github.com/coqui-ai/TTS) — 35K+ звёзд
* [Bark на GitHub](https://github.com/suno-ai/bark) — 38K+ звёзд
* [Kokoro на GitHub](https://github.com/hexgrad/kokoro) — 12K+ звёзд
* [Fish Speech на GitHub](https://github.com/fishaudio/fish-speech) — 14K+ звёзд
* [MeloTTS на GitHub](https://github.com/myshell-ai/MeloTTS) — 15K+ звёзд
* [Таблица лидеров TTS Arena](https://huggingface.co/spaces/TTS-AGI/TTS-Arena)

***

## Резюме

| Модель          | Использовать когда                                                              |
| --------------- | ------------------------------------------------------------------------------- |
| **XTTS v2**     | Лучшее голосовое клонирование (реф 3 с), 17 языков, некоммерческое              |
| **Bark**        | Экспрессивный, смех/эффекты, лицензия MIT                                       |
| **Kokoro**      | Быстрый, качественный английский, лицензия Apache                               |
| **Fish Speech** | Лучшее для CJK, клонирование для продакшена, некоммерческое                     |
| **MeloTTS**     | Самый быстрый, в реальном времени, английский с разными акцентами, лицензия MIT |

Для большинства продакшен-развёртываний на Clore.ai:

* **Приложения с голосом в реальном времени** → MeloTTS или Kokoro (бесплатно, быстро, MIT)
* **Сервис клонирования голоса** → XTTS v2 или Fish Speech (проверьте лицензирование)
* **Экспрессивное повествование** → Bark или XTTS v2

***

## Рекомендации Clore.ai по GPU

| Сценарий использования  | Рекомендуемый GPU | Примерная стоимость на Clore.ai |
| ----------------------- | ----------------- | ------------------------------- |
| Разработка/Тестирование | RTX 3090 (24GB)   | \~$0.12/gpu/hr                  |
| Продакшн                | RTX 4090 (24GB)   | \~$0.70/gpu/hr                  |
| Крупномасштабно         | A100 80GB         | \~$1.20/gpu/hr                  |

> 💡 Все примеры в этом руководстве можно развернуть на [Clore.ai](https://clore.ai/marketplace) GPU-серверах. Просматривайте доступные GPU и арендуйте по часам — без обязательств, с полным root-доступом.


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-ru/sravneniya/tts-comparison.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.