> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-ru/audio-i-golos/xtts-coqui.md).

# XTTS (Coqui)

Создавайте естественную речь с клонированием голоса с помощью Coqui XTTS.

{% hint style="success" %}
Все примеры можно запускать на GPU-серверах, арендованных через [маркетплейс CLORE.AI](https://clore.ai/marketplace).
{% endhint %}

## Аренда на CLORE.AI

1. Перейдите на [маркетплейс CLORE.AI](https://clore.ai/marketplace)
2. Отфильтруйте по типу GPU, объёму VRAM и цене
3. Выберите **On-Demand** (фиксированная ставка) или **Spot** (цена ставки)
4. Настройте свой заказ:
   * Выберите Docker-образ
   * Установите порты (TCP для SSH, HTTP для веб-интерфейсов)
   * При необходимости добавьте переменные окружения
   * Введите команду запуска
5. Выберите способ оплаты: **CLORE**, **BTC**, или **USDT/USDC**
6. Создайте заказ и дождитесь развертывания

### Получите доступ к своему серверу

* Найдите данные для подключения в **Мои заказы**
* Веб-интерфейсы: используйте URL HTTP-порта
* SSH: `ssh -p <port> root@<proxy-address>`

## Что такое XTTS?

XTTS (от Coqui) предлагает:

* Высококачественный синтез речи
* Клонирование голоса по 6 секундам аудио
* Поддерживается 17 языков
* Эмоциональное управление
* Поддержка потоковой передачи

## Требования

| Режим              | VRAM | Рекомендуется |
| ------------------ | ---- | ------------- |
| Инференс           | 4 ГБ | RTX 3060      |
| Быстрый вывод      | 6 ГБ | RTX 3080      |
| Потоковая передача | 4 ГБ | RTX 3060      |

## Быстрое развёртывание

**Docker-образ:**

```
pytorch/pytorch:2.11.0-cuda12.8-cudnn9-runtime
```

**Порты:**

```
22/tcp
8000/http
```

**Команда:**

```bash
pip install TTS && \
tts-server --model_name tts_models/multilingual/multi-dataset/xtts_v2
```

## Доступ к вашему сервису

После развертывания найдите свой `http_pub` URL в **Мои заказы**:

1. Перейдите на **Мои заказы** страницу
2. Нажмите на свой заказ
3. Найдите `http_pub` URL (например, `abc123.clorecloud.net`)

Используйте `https://YOUR_HTTP_PUB_URL` вместо `localhost` в примерах ниже.

## Установка

```bash
pip install TTS
```

## Базовое использование

### Простой TTS

```python
from TTS.api import TTS

# Загрузить XTTS v2
tts = TTS("tts_models/multilingual/multi-dataset/xtts_v2").to("cuda")

# Сгенерировать речь
tts.tts_to_file(
    text="Привет, это тест системы преобразования текста в речь XTTS.",
    file_path="output.wav",
    language="en"
)
```

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

```python
from TTS.api import TTS

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

# Клонировать голос из эталонного аудио (6+ секунд)
tts.tts_to_file(
    text="Это мой клонированный голос, произносящий новый текст.",
    file_path="cloned_output.wav",
    speaker_wav="reference_voice.wav",
    language="en"
)
```

## Несколько языков

```python
from TTS.api import TTS

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

# Английский
tts.tts_to_file(
    text="Привет, как ты сегодня?",
    file_path="english.wav",
    speaker_wav="voice.wav",
    language="en"
)

# Испанский
tts.tts_to_file(
    text="Привет, как ты сегодня?",
    file_path="spanish.wav",
    speaker_wav="voice.wav",
    language="es"
)

# Немецкий
tts.tts_to_file(
    text="Привет, как ты сегодня?",
    file_path="german.wav",
    speaker_wav="voice.wav",
    language="de"
)

# Русский
tts.tts_to_file(
    text="Привет, как дела?",
    file_path="russian.wav",
    speaker_wav="voice.wav",
    language="ru"
)
```

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

| Код   | Язык          |
| ----- | ------------- |
| en    | Английский    |
| es    | Испанский     |
| fr    | Французский   |
| de    | Немецкий      |
| it    | Итальянский   |
| pt    | Португальский |
| pl    | Польский      |
| tr    | Турецкий      |
| ru    | Русский       |
| nl    | Нидерландский |
| cs    | Чешский       |
| ar    | Арабский      |
| zh-cn | Китайский     |
| ja    | Японский      |
| hu    | Венгерский    |
| ko    | Корейский     |
| hi    | Хинди         |

## Потоковый TTS

```python
from TTS.tts.configs.xtts_config import XttsConfig
from TTS.tts.models.xtts import Xtts
import torch
import sounddevice as sd

# Загрузить модель
config = XttsConfig()
config.load_json("path/to/config.json")
model = Xtts.init_from_config(config)
model.load_checkpoint(config, checkpoint_dir="path/to/model")
model.cuda()

# Получить эмбеддинг диктора
gpt_cond_latent, speaker_embedding = model.get_conditioning_latents(
    audio_path="reference.wav"
)

# Генерация потока
chunks = model.inference_stream(
    text="Это потоковый тест системы XTTS.",
    language="en",
    gpt_cond_latent=gpt_cond_latent,
    speaker_embedding=speaker_embedding,
    stream_chunk_size=20
)

# Воспроизводить в реальном времени
for chunk in chunks:
    audio = chunk.cpu().numpy()
    sd.play(audio, samplerate=24000)
    sd.wait()
```

## Интерфейс Gradio

```python
import gradio as gr
from TTS.api import TTS
import tempfile

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

def generate_speech(text, reference_audio, language):
    with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as f:
        if reference_audio:
            tts.tts_to_file(
                text=text,
                file_path=f.name,
                speaker_wav=reference_audio,
                language=language
            )
        else:
            tts.tts_to_file(
                text=text,
                file_path=f.name,
                language=language
            )
        return f.name

demo = gr.Interface(
    fn=generate_speech,
    inputs=[
        gr.Textbox(label="Текст для озвучивания", lines=5),
        gr.Audio(type="filepath", label="Эталонный голос (необязательно)"),
        gr.Dropdown(
            ["en", "es", "fr", "de", "it", "pt", "ru", "zh-cn", "ja"],
            value="en",
            label="Язык"
        )
    ],
    outputs=gr.Audio(label="Сгенерированная речь"),
    title="Клонирование голоса XTTS"
)

demo.launch(server_name="0.0.0.0", server_port=7860)
```

## API-сервер

```python
from fastapi import FastAPI, UploadFile, File, Form
from fastapi.responses import FileResponse
from TTS.api import TTS
import tempfile
import os

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

@app.post("/synthesize")
async def synthesize(
    text: str = Form(...),
    language: str = Form(default="en"),
    speaker: UploadFile = File(default=None)
):
    with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as out_file:
        if speaker:
            # Сохранить загруженный эталон
            with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as ref_file:
                ref_file.write(await speaker.read())
                ref_path = ref_file.name

            tts.tts_to_file(
                text=text,
                file_path=out_file.name,
                speaker_wav=ref_path,
                language=language
            )
            os.unlink(ref_path)
        else:
            tts.tts_to_file(
                text=text,
                file_path=out_file.name,
                language=language
            )

        return FileResponse(out_file.name, media_type="audio/wav")

# Запуск: uvicorn server:app --host 0.0.0.0 --port 8000
```

## Пакетная обработка

```python
from TTS.api import TTS
import os

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

texts = [
    "Добро пожаловать на нашу платформу.",
    "Пожалуйста, ознакомьтесь со следующей информацией.",
    "Благодарим за внимание.",
    "Хорошего дня!"
]

reference_voice = "speaker.wav"
output_dir = "./audio_files"
os.makedirs(output_dir, exist_ok=True)

for i, text in enumerate(texts):
    output_path = f"{output_dir}/audio_{i:03d}.wav"

    tts.tts_to_file(
        text=text,
        file_path=output_path,
        speaker_wav=reference_voice,
        language="en"
    )

    print(f"Создано: {output_path}")
```

## Тонкая настройка голоса

Для лучшего клонирования голоса:

```python
from TTS.tts.configs.xtts_config import XttsConfig
from TTS.tts.models.xtts import Xtts

config = XttsConfig()
model = Xtts.init_from_config(config)

# Используйте несколько эталонных образцов для лучшего качества
reference_files = [
    "sample1.wav",
    "sample2.wav",
    "sample3.wav"
]

# Извлечь эмбеддинг диктора из нескольких образцов
gpt_cond_latent, speaker_embedding = model.get_conditioning_latents(
    audio_path=reference_files
)

# Генерировать со средним эмбеддингом
output = model.inference(
    text="Клонированная речь высокого качества.",
    language="en",
    gpt_cond_latent=gpt_cond_latent,
    speaker_embedding=speaker_embedding
)
```

## Предобработка аудио

```python
import librosa
import soundfile as sf

def prepare_reference(input_path, output_path, target_sr=22050):
    # Загрузить и ресемплировать
    audio, sr = librosa.load(input_path, sr=target_sr)

    # Обрезать тишину
    audio, _ = librosa.effects.trim(audio, top_db=20)

    # Нормализовать
    audio = librosa.util.normalize(audio)

    # Сохранить
    sf.write(output_path, audio, target_sr)

# Подготовить эталонное аудио
prepare_reference("raw_voice.wav", "clean_voice.wav")
```

## Производительность

| Режим              | GPU      | Скорость                  |
| ------------------ | -------- | ------------------------- |
| Стандартный        | RTX 3060 | \~0.5x в реальном времени |
| Стандартный        | RTX 4090 | \~2x в реальном времени   |
| Потоковая передача | RTX 3060 | \~1x в реальном времени   |
| Потоковая передача | RTX 4090 | \~3x в реальном времени   |

## Советы по качеству

* Используйте 6–15 секунд чистого эталонного аудио
* Избегайте фонового шума в эталоне
* Сопоставьте язык текста и эталона
* Используйте несколько эталонных образцов для лучших результатов

## Устранение неполадок

### Плохое качество голоса

* Чистое эталонное аудио
* Более длинный эталон (10+ секунд)
* Согласуйте манеру речи

### Неправильное произношение языка

* Убедитесь, что указан правильный код языка
* Используйте эталон носителя языка

### Медленная генерация

* Включите вывод на GPU
* Используйте потоковый режим
* Уменьшите длину текста за один вызов

## Оценка стоимости

Типичные цены на маркетплейсе CLORE.AI (по состоянию на 2024 год):

| GPU        | Почасовая ставка | Дневная ставка | 4-часовая сессия |
| ---------- | ---------------- | -------------- | ---------------- |
| RTX 3060   | \~$0.03          | \~$0.70        | \~$0.12          |
| RTX 3090   | \~$0.06          | \~$1.50        | \~$0.25          |
| RTX 4090   | \~$0.10          | \~$2.30        | \~$0.40          |
| A100 40 ГБ | \~$0.17          | \~$4.00        | \~$0.70          |
| A100 80 ГБ | \~$0.25          | \~$6.00        | \~$1.00          |

*Цены зависят от провайдера и спроса. Проверьте* [*маркетплейс CLORE.AI*](https://clore.ai/marketplace) *актуальные тарифы.*

**Сэкономьте деньги:**

* Используйте **Spot** рынок для прерываемых задач — примерно треть серверов оценивает spot-цены ниже on-demand (медиана \~13% скидки), остальные совпадают с ними
* Платите **CLORE** токенами
* Сравните цены у разных провайдеров

## Дальнейшие шаги

* [Bark TTS](/guides/guides_v2-ru/audio-i-golos/bark-tts.md) - Выразительный TTS
* [SadTalker](/guides/guides_v2-ru/govoryashie-golovy/sadtalker.md) - Говорящие головы
* [Клонирование голоса RVC](/guides/guides_v2-ru/audio-i-golos/rvc-voice-clone.md) - Преобразование голоса


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## 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, and the optional `goal` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-ru/audio-i-golos/xtts-coqui.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

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.