> 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/melotts.md).

# MeloTTS

MeloTTS — это высококачественная многоязычная библиотека синтеза речи, разработанная **MyShell AI**. Она обеспечивает быстрый, естественно звучащий синтез речи на нескольких языках и с английскими акцентами, предназначенный как для исследований, так и для промышленного развертывания. MeloTTS оптимизирована по скорости — она может генерировать речь значительно быстрее, чем в реальном времени, даже на CPU — при этом сохраняя высокое качество звука, пригодное для коммерческого использования.

MeloTTS в настоящее время поддерживает:

* **Английский** (американский, британский, индийский, австралийский, по умолчанию)
* **Китайский (упрощённый и смешанный китайско-английский)**
* **Японский**
* **Корейский**
* **Испанский**
* **Французский**

Ключевые моменты:

* ⚡ **Быстрый инференс** — быстрее, чем в реальном времени на CPU, и молниеносно быстро на GPU
* 🌍 **Многоязычность** — 6 языков с вариантами акцента для английского
* 🐳 **Готово для Docker** — доступен официальный Docker-образ
* 🔌 **REST API** — HTTP API для интеграции в любое приложение
* 📱 **Промышленного уровня** — используется в потребительских продуктах MyShell

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

***

## Требования к серверу

| Параметр | Минимум                | Рекомендуется           |
| -------- | ---------------------- | ----------------------- |
| GPU      | NVIDIA GTX 1080 (8 GB) | NVIDIA RTX 3090 (24 GB) |
| VRAM     | 4 ГБ                   | 8–16 GB                 |
| ОЗУ      | 8 ГБ                   | 16 ГБ                   |
| CPU      | 4 ядра                 | 8 ядер                  |
| Диск     | 10 ГБ                  | 20 ГБ                   |
| ОС       | Ubuntu 20.04+          | Ubuntu 22.04            |
| CUDA     | 11.7+ (необязательно)  | 12.1+                   |
| Python   | 3.8+                   | 3.10                    |
| Порты    | 22, 8888               | 22, 8888                |

{% hint style="info" %}
MeloTTS исключительно эффективна — она хорошо работает на CPU для единичных запросов и очень выигрывает от GPU при пакетной обработке. Даже бюджетный GPU значительно удваивает пропускную способность.
{% endhint %}

***

## Быстрое развертывание на CLORE.AI

{% hint style="warning" %}
**Примечание:** У MeloTTS нет официального готового Docker-образа в Docker Hub (`myshell-ai/melotts` не существует). Рекомендуемый подход — использовать базовый образ NVIDIA CUDA и установить MeloTTS через pip из официального репозитория GitHub.
{% endhint %}

### 1. Найдите подходящий сервер

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

* **VRAM**: ≥ 4 ГБ (или только CPU для низкой нагрузки)
* **GPU**: Любой GPU NVIDIA (GTX 1080+, серия RTX, A100)
* **Диск**: ≥ 10 ГБ

### 2. Настройте своё развёртывание

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

```
nvidia/cuda:12.8.1-devel-ubuntu22.04
```

**Сопоставление портов:**

```
22   → доступ по SSH
8888 → API-сервер MeloTTS
```

**Переменные среды:**

```
NVIDIA_VISIBLE_DEVICES=all
```

**Команда запуска** (выполнить после подключения по SSH к серверу):

```bash
apt-get update && apt-get install -y python3-pip ffmpeg espeak-ng git && \
git clone https://github.com/myshell-ai/MeloTTS.git && \
cd MeloTTS && pip install -e . && \
python -m unidic download && \
python3 -c "import nltk; nltk.download('averaged_perceptron_tagger_eng')" && \
python -m melo.api_server --host 0.0.0.0 --port 8888
```

### 3. Доступ к API

```
http://<your-clore-server-ip>:8888
```

Проверьте с помощью:

```bash
curl -X POST http://<server-ip>:8888/synthesize \
  -H "Content-Type: application/json" \\
  -d '{"text": "Привет от Clore.ai!", "language": "EN", "speaker_id": "EN-Default"}'
```

***

## Пошаговая настройка

### Шаг 1: Подключитесь к серверу по SSH

```bash
ssh root@<your-clore-server-ip> -p <ssh-port>
```

### Шаг 2: Соберите и запустите контейнер

Поскольку у MeloTTS нет готового образа в Docker Hub, используйте базовый образ NVIDIA CUDA и установите MeloTTS из исходников:

```bash
# Запустите контейнер CUDA и установите в него MeloTTS
docker run -d \
  --name melotts \
  --gpus all \
  -p 8888:8888 \
  -v /workspace/melotts/outputs:/app/outputs \
  -e NVIDIA_VISIBLE_DEVICES=all \
  nvidia/cuda:12.8.1-devel-ubuntu22.04 \
  bash -c "apt-get update && apt-get install -y python3-pip ffmpeg espeak-ng git && \
    git clone https://github.com/myshell-ai/MeloTTS.git /app/MeloTTS && \
    cd /app/MeloTTS && pip install -e . && \
    python -m unidic download && \
    python3 -c \"import nltk; nltk.download('averaged_perceptron_tagger_eng')\" && \
    python -m melo.api_server --host 0.0.0.0 --port 8888"
```

В качестве альтернативы соберите собственный Docker-образ из исходников:

```bash
git clone https://github.com/myshell-ai/MeloTTS.git
cd MeloTTS
docker build -t melotts:local .
docker run -d \
  --name melotts \
  --gpus all \
  -p 8888:8888 \
  melotts:local
```

### Шаг 3: Проверьте, что сервис работает

```bash
# Проверить журналы контейнера
docker logs -f melotts

# Подождите запуска, затем проверьте
curl http://localhost:8888/health
```

### Шаг 4: Альтернатива — интерфейс Jupyter Notebook

```bash
docker run -d \
  --name melotts-jupyter \
  --gpus all \
  -p 8888:8888 \
  nvidia/cuda:12.8.1-devel-ubuntu22.04 \
  bash -c "pip install jupyter melo-tts && \
    jupyter notebook --ip=0.0.0.0 --port=8888 --no-browser --allow-root"
```

Доступно по адресу: `http://<server-ip>:8888`

### Шаг 5: Установка через pip (без Docker)

```bash
# Установите системные зависимости
apt-get install -y python3-pip ffmpeg espeak-ng

# Установите MeloTTS
pip install melo-tts

# Загрузите необходимые данные NLTK
python3 -c "import nltk; nltk.download('averaged_perceptron_tagger_eng')"
```

***

## Примеры использования

### Пример 1: Базовый английский TTS (Python)

```python
from melo.api import TTS

# Инициализация английского TTS
speed = 1.0  # Настройка скорости речи (0.5 = медленно, 2.0 = быстро)
device = 'cuda'  # Используйте 'cpu', если GPU недоступен

tts = TTS(language='EN', device=device)

# Получить доступные идентификаторы дикторов
speakers = tts.hps.data.spk2id
print("Доступные дикторы:", list(speakers.keys()))
# Вывод: ['EN-Default', 'EN-US', 'EN-GB', 'EN-India', 'EN-Australia', 'EN-Brazil']

# Сгенерировать речь
speaker_ids = tts.hps.data.spk2id
output_path = "output_english.wav"

tts.tts_to_file(
    text="Добро пожаловать в Clore.ai — вашу облачную GPU-площадку для AI-нагрузок. Арендуйте мощные GPU за считанные минуты.",
    speaker_id=speaker_ids['EN-Default'],
    output_path=output_path,
    speed=speed
)

print(f"Сохранено в: {output_path}")
```

***

### Пример 2: Многоязычный TTS

```python
from melo.api import TTS

device = 'cuda'

# Определите пары язык-текст
language_texts = [
    ('EN', 'EN-US', "GPU-вычисления преобразили исследования и разработку в области искусственного интеллекта."),
    ('EN', 'EN-GB', "Соединённое Королевство лидирует в Европе по инвестициям и инновациям в области ИИ."),
    ('ZH', 'ZH', "Clore.ai — это децентрализованный рынок облачных GPU-вычислений, предоставляющий вычислительные ресурсы разработчикам ИИ."),
    ('JP', 'JP', "Для развития искусственного интеллекта требуются крупные вычислительные ресурсы."),
    ('KR', 'KR', "Clore.ai — это рынок облачных GPU для исследователей ИИ."),
    ('SP', 'SP', "Искусственный интеллект трансформирует все отрасли по всему миру."),
    ('FR', 'FR', "Искусственный интеллект революционизирует то, как мы работаем и живём."),
]

for lang, speaker, text in language_texts:
    try:
        tts = TTS(language=lang, device=device)
        speaker_id = tts.hps.data.spk2id[speaker]

        output_file = f"output_{lang}_{speaker}.wav"
        tts.tts_to_file(text=text, speaker_id=speaker_id, output_path=output_file)
        print(f"✓ Создано [{lang}]: {output_file}")
    except Exception as e:
        print(f"✗ Ошибка [{lang}]: {e}")
```

***

### Пример 3: Использование REST API

```python
import requests
import json

API_BASE = "http://<your-clore-server-ip>:8888"

# Проверить доступные голоса
response = requests.get(f"{API_BASE}/voices")
print("Доступные голоса:", json.dumps(response.json(), indent=2))

# Синтезировать речь
def synthesize(text, language="EN", speaker="EN-Default", speed=1.0):
    payload = {
        "text": text,
        "language": language,
        "speaker_id": speaker,
        "speed": speed,
        "format": "wav"
    }

    response = requests.post(
        f"{API_BASE}/synthesize",
        json=payload,
        timeout=30
    )

    if response.status_code == 200:
        return response.content
    else:
        raise Exception(f"Ошибка API: {response.status_code} - {response.text}")

# Сгенерировать примеры
samples = [
    ("Привет, это MeloTTS, работающий на GPU-серверах Clore.ai.", "EN", "EN-US"),
    ("Это вариант британского английского акцента.", "EN", "EN-GB"),
    ("Позвольте мне продемонстрировать вариант индийского английского акцента.", "EN", "EN-India"),
]

for text, lang, speaker in samples:
    audio_bytes = synthesize(text, lang, speaker)
    filename = f"api_output_{speaker.replace('-', '_')}.wav"
    with open(filename, "wb") as f:
        f.write(audio_bytes)
    print(f"Сохранено: {filename}")
```

***

### Пример 4: Высокоскоростная пакетная обработка

```python
from melo.api import TTS
from concurrent.futures import ThreadPoolExecutor
import soundfile as sf
import time
import numpy as np
from pathlib import Path

device = 'cuda'
tts = TTS(language='EN', device=device)
speaker_id = tts.hps.data.spk2id['EN-US']

# Большой пакет текстов
texts = [
    f"Это предложение номер {i}. Оно демонстрирует быструю пакетную обработку с MeloTTS на GPU-инфраструктуре Clore.ai."
    for i in range(1, 51)  # 50 предложений
]

output_dir = Path("batch_output")
output_dir.mkdir(exist_ok=True)

start_time = time.time()

# Обработать пакет
for i, text in enumerate(texts):
    output_path = str(output_dir / f"batch_{i+1:03d}.wav")
    tts.tts_to_file(
        text=text,
        speaker_id=speaker_id,
        output_path=output_path,
        speed=1.0,
        quiet=True
    )
    if (i + 1) % 10 == 0:
        elapsed = time.time() - start_time
        print(f"Прогресс: {i+1}/50 | Время: {elapsed:.1f}s | Скорость: {(i+1)/elapsed:.1f} предложений/сек")

total_time = time.time() - start_time
print(f"\nПакетная обработка завершена: {len(texts)} предложений за {total_time:.1f}s")
print(f"В среднем: {total_time/len(texts)*1000:.0f} мс на предложение")
```

***

### Пример 5: Смешанный китайско-английский TTS

```python
from melo.api import TTS

device = 'cuda'
tts = TTS(language='ZH', device=device)
speaker_id = tts.hps.data.spk2id['ZH']

# Смешанный текст на двух языках (китайский + английский)
mixed_texts = [
    "Мы используем GPU-серверы Clore.ai для запуска machine learning workloads.",
    "Сегодня на AI-конференции обсуждались large language models и технологии speech synthesis.",
    "Моему startup нужны GPU-ресурсы для обучения нашей модели deep learning.",
    "Clore.ai предлагает очень competitive цены, намного дешевле, чем AWS и GCP.",
]

for i, text in enumerate(mixed_texts):
    output_file = f"mixed_zh_en_{i+1}.wav"
    tts.tts_to_file(
        text=text,
        speaker_id=speaker_id,
        output_path=output_file,
        speed=0.9  # Немного медленнее для большей разборчивости
    )
    print(f"Сгенерировано: {output_file}")
    print(f"  Текст: {text[:60]}...")
```

***

## Конфигурация

### Настройка Docker Compose

Поскольку у MeloTTS нет официального образа в Docker Hub, используйте базовый образ NVIDIA CUDA и устанавливайте MeloTTS из исходников при запуске:

```yaml
version: '3.8'

services:
  melotts:
    image: nvidia/cuda:12.8.1-devel-ubuntu22.04
    container_name: melotts
    runtime: nvidia
    environment:
      - NVIDIA_VISIBLE_DEVICES=all
      - PYTHONDONTWRITEBYTECODE=1
    ports:
      - "8888:8888"
    volumes:
      - ./outputs:/app/outputs
      - ./cache:/root/.cache
    command: >
      bash -c "apt-get update && apt-get install -y python3-pip ffmpeg espeak-ng git &&
      git clone https://github.com/myshell-ai/MeloTTS.git /app/MeloTTS &&
      cd /app/MeloTTS && pip install -e . &&
      python -m unidic download &&
      python3 -c 'import nltk; nltk.download(\"averaged_perceptron_tagger_eng\")' &&
      python -m melo.api_server --host 0.0.0.0 --port 8888"
    restart: unless-stopped
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8888/health"]
      interval: 30s
      timeout: 10s
      retries: 3
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: 1
              capabilities: [gpu]
```

### Параметры конфигурации API

| Параметр    | По умолчанию | Описание                                                      |
| ----------- | ------------ | ------------------------------------------------------------- |
| `--host`    | `127.0.0.1`  | Адрес привязки (используйте `0.0.0.0` для публичного доступа) |
| `--port`    | `8888`       | Порт API-сервера                                              |
| `--workers` | `1`          | Количество рабочих процессов                                  |
| `--device`  | `авто`       | `cuda`, `cpu`, или `авто`                                     |

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

| Язык        | Код  | Идентификаторы дикторов                                                 |
| ----------- | ---- | ----------------------------------------------------------------------- |
| Английский  | `EN` | `EN-Default`, `EN-US`, `EN-GB`, `EN-India`, `EN-Australia`, `EN-Brazil` |
| Китайский   | `ZH` | `ZH`                                                                    |
| Японский    | `JP` | `JP`                                                                    |
| Корейский   | `KR` | `KR`                                                                    |
| Испанский   | `SP` | `SP`                                                                    |
| Французский | `FR` | `FR`                                                                    |

***

## Советы по производительности

### 1. Сравнение GPU и CPU

Производительность MeloTTS (RTF = коэффициент реального времени, ниже — лучше):

| Устройство   | RTF     | Примечания                                   |
| ------------ | ------- | -------------------------------------------- |
| CPU (8 ядер) | \~0.3x  | Быстро, отлично подходит для низкой нагрузки |
| RTX 3080     | \~0.05x | В 20 раз быстрее, чем в реальном времени     |
| RTX 4090     | \~0.02x | В 50 раз быстрее, чем в реальном времени     |
| A100         | \~0.01x | В 100 раз быстрее, чем в реальном времени    |

### 2. Оптимизируйте пропускную способность

```python
# Отключите вычисление градиентов для инференса
import torch

with torch.no_grad():
    tts.tts_to_file(text, speaker_id, output_path)
```

### 3. Предварительно прогрейте модель

```python
# Выполните прогон для прогрева, чтобы загрузить CUDA-ядра
tts.tts_to_file(
    text="warmup",
    speaker_id=speaker_id,
    output_path="/dev/null"
)
print("Модель прогрета, готова к быстрому инференсу")
```

### 4. Настройте баланс между качеством и скоростью

```python
# Быстрее (чуть ниже качество)
tts.tts_to_file(text, speaker_id, output_path, speed=1.2)

# Более медленная речь (лучшая артикуляция)
tts.tts_to_file(text, speaker_id, output_path, speed=0.8)
```

### 5. Эффективность использования памяти

```python
# Освобождайте память GPU между большими пакетами
import gc
import torch

gc.collect()
torch.cuda.empty_cache()
```

***

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

### Проблема: `espeak-ng` не найден

```bash
apt-get install -y espeak-ng
python3 -c "import phonemizer; print('phonemizer в порядке')"
```

### Проблема: отсутствуют данные NLTK

```bash
python3 -c "
import nltk
nltk.download('averaged_perceptron_tagger_eng')
nltk.download('punkt')
"
```

### Проблема: порт 8888 конфликтует с Jupyter

MeloTTS по умолчанию использует порт 8888, который конфликтует с Jupyter Notebook. Решения:

```bash
# Вариант 1: Запустите MeloTTS на другом порту
python -m melo.api_server --host 0.0.0.0 --port 8889

# Вариант 2: Запустите Jupyter на другом порту
jupyter notebook --port 8890
```

### Проблема: китайский текст отображается некорректно

```bash
# Установите поддержку китайского языка
pip install jieba
apt-get install -y python3-opencc

# Проверка
python3 -c "from melo.api import TTS; t = TTS('ZH'); print('ZH в порядке')"
```

### Проблема: не удаётся загрузить Docker-образ

```bash
# Вместо этого соберите из исходников
git clone https://github.com/myshell-ai/MeloTTS.git
cd MeloTTS
pip install -e .
python3 -c "import nltk; nltk.download('averaged_perceptron_tagger_eng')"
```

### Проблема: медленный инференс на GPU

```bash
# Проверьте, что используется GPU
python3 -c "
import torch
from melo.api import TTS
tts = TTS('EN', device='cuda')
print(f'Device: {next(tts.model.parameters()).device}')
print(f'CUDA доступна: {torch.cuda.is_available()}')
"
```

***

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

MeloTTS лёгкая — она хорошо работает на CPU при низкой нагрузке и линейно масштабируется вместе с вычислительной мощностью GPU. Вам не нужно дорогое оборудование.

| GPU        | VRAM  | Цена Clore.ai                               | RTF (коэффициент реального времени)       | Производительность |
| ---------- | ----- | ------------------------------------------- | ----------------------------------------- | ------------------ |
| Только CPU | —     | \~$0.02/hr                                  | \~0.3×                                    | \~3 req/min        |
| RTX 3090   | 24 ГБ | $0.07–0.21/ч                                | \~0.02× (50× быстрее реального времени)   | \~100 req/min      |
| RTX 4090   | 24 ГБ | $0.14–0.42/ч                                | \~0.01× (100× быстрее реального времени)  | \~200 req/min      |
| A100 40 ГБ | 40 ГБ | [голое железо](https://clore.ai/bare-metal) | \~0.005× (200× быстрее реального времени) | \~400 req/min      |

{% hint style="info" %}
**Лучшее соотношение цены и качества для TTS-нагрузок:** RTX 3090 за $0.07–0.21/ч обеспечивает скорость TTS в 50 раз выше реального времени. Для production-API, обслуживающего сотни пользователей, этого более чем достаточно. Инстансы только на CPU ($0.07–0.21/ч) отлично подходят для разработки и развертываний с низким трафиком.
{% endhint %}

**Рекомендация для продакшена:** Для многоязычного TTS API, обслуживающего 10–50 одновременных пользователей, RTX 3090 — это оптимальный вариант. Масштабируйтесь горизонтально (несколько инстансов), а не переходите на дорогой A100 — MeloTTS не получает пропорциональной выгоды от более дорогих GPU.

***

## Ссылки

* **GitHub**: <https://github.com/myshell-ai/MeloTTS>
* **Docker**: Официального образа в Docker Hub нет — устанавливайте из [исходного кода GitHub](https://github.com/myshell-ai/MeloTTS) с использованием `nvidia/cuda:12.8.1-devel-ubuntu22.04` базового образа
* **Статья**: <https://arxiv.org/abs/2406.06753>
* **Hugging Face**: <https://huggingface.co/myshell-ai/MeloTTS-English>
* **MyShell AI**: <https://myshell.ai>
* **маркетплейс CLORE.AI**: <https://clore.ai/marketplace>


---

# 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/melotts.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.