# 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 ГБ) | NVIDIA RTX 3090 (24 ГБ) |
| VRAM     | 4 ГБ                   | 8–16 ГБ                 |
| ОЗУ      | 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**: Любая NVIDIA GPU (GTX 1080+, серия RTX, A100)
* **Диск**: ≥ 10 ГБ

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

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

```
nvidia/cuda:12.1.0-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": "Hello from Clore.ai!", "language": "EN", "speaker_id": "EN-Default"}'
```

***

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

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

```bash
ssh root@<ip-вашего-clore-сервера> -p <ssh-порт>
```

### Шаг 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.1.0-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.1.0-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="Welcome to Clore.ai, your GPU cloud marketplace for AI workloads. Rent powerful GPUs in minutes.",
    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 computing has transformed artificial intelligence research and development."),
    ('EN', 'EN-GB', "The United Kingdom leads Europe in AI investment and innovation."),
    ('ZH', 'ZH', "Clore.ai是一个去中心化的GPU云计算市场，为AI开发者提供算力服务。"),
    ('JP', 'JP', "人工知能の発展には大規模な計算資源が必要です。"),
    ('KR', 'KR', "Clore.ai는 AI 연구자를 위한 GPU 클라우드 마켓플레이스입니다."),
    ('SP', 'SP', "La inteligencia artificial está transformando todas las industrias del mundo."),
    ('FR', 'FR', "L'intelligence artificielle révolutionne la façon dont nous travaillons et vivons."),
]

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 = [
    ("Hello, this is MeloTTS running on Clore.ai GPU servers.", "EN", "EN-US"),
    ("This is the British English accent variant.", "EN", "EN-GB"),
    ("Let me demonstrate the Indian English accent.", "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"This is sentence number {i}. It demonstrates fast batch processing with MeloTTS on Clore.ai GPU infrastructure."
    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 = [
    "我们使用Clore.ai的GPU服务器来运行machine learning workloads。",
    "今天的AI conference讨论了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.1.0-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`  | `auto`       | `cuda`, `cpu`, или `auto`                                      |

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

| Язык        | Код  | Идентификаторы дикторов                                                 |
| ----------- | ---- | ----------------------------------------------------------------------- |
| Английский  | `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 OK')"
```

### Проблема: отсутствуют данные 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 OK')"
```

### Проблема: ошибка при загрузке образа 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 available: {torch.cuda.is_available()}')
"
```

***

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

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

| GPU        | VRAM  | Цена Clore.ai | RTF (коэффициент реального времени) | Вместимость    |
| ---------- | ----- | ------------- | ----------------------------------- | -------------- |
| Только CPU | —     | \~$0.02/ч     | \~0.3×                              | \~3 запр/мин   |
| RTX 3090   | 24 ГБ | \~$0.12/ч     | \~0.02× (50× реального времени)     | \~100 запр/мин |
| RTX 4090   | 24 ГБ | \~$0.70/ч     | \~0.01× (100× реального времени)    | \~200 запр/мин |
| A100 40GB  | 40 ГБ | \~$1.20/ч     | \~0.005× (200× реального времени)   | \~400 запр/мин |

{% hint style="info" %}
**Лучшее соотношение цена/производительность для TTS задач:** RTX 3090 при ~~$0.12/час обеспечивает скорость TTS в 50× реального времени. Для производственного API, обслуживающего сотни пользователей, этого более чем достаточно. Инстансы только с CPU (~~$0.02/час) подходят для разработки и развертываний с низким трафиком.
{% 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.1.0-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: 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/audio-i-golos/melotts.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.