XTTS (Coqui)

Естественная генерация речи с клонированием голоса с помощью Coqui XTTS

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

Все примеры можно запускать на GPU-серверах, арендованных через маркетплейс CLORE.AI.

Аренда на CLORE.AI

1. Перейдите на маркетплейс CLORE.AI

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

Команда:

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 в примерах ниже.

Установка

pip install TTS

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

Простой TTS

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"
)

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

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"
)

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

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

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

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-сервер

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

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

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}")

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

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

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
)

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

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 актуальные тарифы.

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

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

• Платите CLORE токенами

• Сравните цены у разных провайдеров

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

• Bark TTS - Выразительный TTS

• SadTalker - Говорящие головы

• Клонирование голоса RVC - Преобразование голоса