> 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-zh/dui-bi/tts-comparison.md).

# TTS 引擎对比

比较可部署在 Clore.ai GPU 服务器上的领先开源文本转语音引擎。

{% 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          |
| **最低显存**      | 4GB             | 8GB     | **CPU 可用** | 4GB         | **CPU 可用** |
| **许可证**       | CPML（非商业）       | MIT     | Apache 2.0 | CC BY-NC-SA | MIT        |
| **GitHub 星标** | 35K+（Coqui TTS） | 38K+    | 12K+       | 14K+        | 15K+       |

***

## 概览

### XTTS v2

Coqui 的 XTTS v2 是开源声音克隆 TTS 的黄金标准。它可以仅凭 3 秒音频片段克隆任何声音，并具有极高的保真度。

**理念**：最大表达力和声音克隆质量。

```python
from TTS.api import TTS

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

# 基于 3 秒参考音频进行零样本声音克隆
tts.tts_to_file(
    text="你好，这是一个以克隆声音自然说话的示例。",
    speaker_wav="reference_voice.wav",
    language="en",
    file_path="output.wav"
)
```

### Bark

Suno 的 Bark 是一款基于 Transformer 的 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] 你好！[clears throat] 这是 Bark TTS。[sighs]"
)
write_wav("output.wav", SAMPLE_RATE, audio_array)
```

### Kokoro

Kokoro 是一款轻量、快速的 TTS 模型，针对英语进行了优化。尽管体积很小（约 8200 万参数），但它能提供令人惊讶的高质量。

**理念**：小模型，大质量，随处可运行。

```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 Audio 的 Fish Speech 是一款可用于生产环境的 TTS，能从短音频片段中进行出色的声音克隆。它采用了一种新颖的 codec + 语言模型架构。

**理念**：生产级质量、快速推理、出色克隆。

```python
# 通过 HTTP API 使用 Fish Speech
import requests

response = requests.post(
    "http://localhost:8080/v1/tts",
    json={
        "text": "你好，这是 Fish Speech 生成的音频。",
        "reference_id": "your-voice-id",
        "format": "wav",
    }
)

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

### MeloTTS

MyShell 的 MeloTTS 是一款超快速、多口音 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(
    "你好，世界！MeloTTS 非常快。",
    speaker_ids['EN-Default'],
    output_path,
    speed=speed
)
```

***

## 质量对比

### 自然度评分（MOS——平均意见分，1-5）

{% hint style="info" %}
MOS 分数是基于已发表论文和社区评测得出的近似值。实际质量在很大程度上取决于文本内容和声音配置。
{% endhint %}

| 模型          | 英语 MOS | 多语言 MOS  | 表现力       |
| ----------- | ------ | -------- | --------- |
| XTTS v2     | 4.3    | 4.1      | ⭐⭐⭐⭐⭐     |
| Bark        | 3.9    | 3.7      | ⭐⭐⭐⭐⭐（独特） |
| Kokoro      | 4.2    | 不适用（仅英语） | ⭐⭐⭐       |
| Fish Speech | 4.4    | 4.2      | ⭐⭐⭐⭐      |
| MeloTTS     | 3.8    | 3.6      | ⭐⭐        |

### 每个模型最擅长什么

| 模型          | 突出质量特性            |
| ----------- | ----------------- |
| XTTS v2     | 近乎完美的声音克隆、丰富的情感范围 |
| Bark        | 非语音声音、笑声、音乐、音效    |
| Kokoro      | 最佳的质量/体积比、自然的节奏   |
| Fish Speech | 整体自然度 + 克隆准确度最佳   |
| MeloTTS     | 长文本输出稳定、干净        |

***

## 速度基准

### 每秒字符数（CPU 与 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 秒    | \~2s     |
| Fish Speech | \~45秒    | \~8s     | \~3s     |
| MeloTTS     | **\~8s** | **\~2s** | **<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   | 英语（美式/英式）、日语（有限）                                                   |
| 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 %}

***

## 声音克隆对比

### 克隆能力

| 模型          | 参考长度    | 克隆质量  | 零样本 |
| ----------- | ------- | ----- | --- |
| 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="""
    欢迎来到我们的播客。今天我们在讨论 AI 的未来 
    及其对社会的影响。我是你的主持人，很高兴 
    与大家分享一些有趣的见解。
    """,
    speaker_wav="speaker_sample.wav",  # 你的参考音频
    language="en",
    file_path="cloned_voice_output.wav"
)
```

### Fish Speech 声音克隆

```bash
# 从参考音频克隆
fish_speech_cli tts \\
  --text "这是我克隆的声音在说一句新句子。" \\
  --reference-audio speaker_sample.wav \\
  --reference-text "参考音频中说出的原始文本。" \\
  --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(
    "欢迎！[laughs] 这项技术真是太令人着迷了。",
    history_prompt=voice_presets["female_US"]
)
write("bark_output.wav", SAMPLE_RATE, audio)
```

***

## XTTS v2：深度解析

### 架构

* **VITS + GPT** 混合架构
* 在 17 种语言上接受了超过 1.6 万小时的训练
* 零样本克隆最少需要 3 秒

### 在 Clore.ai 上安装

```bash
pip install TTS
# GPU 版本
pip install TTS[all]
```

### Docker 部署

```dockerfile
FROM nvidia/cuda:12.8.1-cudnn-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 风格 Transformer** 用于音频 token 生成
* 三阶段流程：文本 → 语义 → 粗粒度 → 细粒度 token
* 生成实际音频 codec token（EnCodec）

### Bark 的独特之处

Bark 是唯一一款原生生成以下内容的开源 TTS：

* 🎵 语音中的背景音乐
* 😂 笑声、叹息、清嗓
* 🎭 一次生成中包含多个说话者
* 🌍 混合语言语句

### 标记语言

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

# 用于增强表现力的特殊 token
text = """
[clears throat] 大家早上好。[laughs] 
今天的演讲将涵盖…… 
[sighs deeply] ……其实涉及很多内容。
[music: upbeat jazz] 让我们开始吧！
"""

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
```

**弱点**：较慢（3 阶段流水线）、每次运行结果不一致、没有真正的声音克隆

***

## Kokoro：深度解析

### 架构

* **8200 万参数** 基于 StyleTTS2 的模型
* 极小，但质量出乎意料地高
* 在 CPU 和 GPU 上推理都很快

### 可用声音

```python
from kokoro import KPipeline

pipeline = KPipeline(lang_code='a')  # 'a' = 美式英语，'b' = 英式英语

# 可用声音
voices = {
    'af_heart': 'American Female（温暖）',
    '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("你好，这是一个测试。", voice=voice_name)
    for _, _, audio in gen:
        print(f"使用 {description} 生成")
```

### 流式支持

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

pipeline = KPipeline(lang_code='a')

# 在生成过程中实时流式输出音频
text = "这是一段很长的文本，会在生成时以流式方式输出，从而提供低延迟音频输出。"

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

**弱点**：主要仅支持英语、不支持声音克隆、表现力有限

***

## Fish Speech：深度解析

### 架构

* **VQGAN + 语言模型** 架构
* 在超过 70 万小时的音频上训练
* 多语言能力强，并支持亚洲语言

### 安装

```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": "来自 Fish Speech 的问候！听起来非常自然。",
            "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": "这段录音中所说的文本。"}
    )
    voice_id = response.json()["id"]

# 使用克隆声音
response = httpx.post(
    "http://localhost:8080/v1/tts",
    json={
        "text": "现在用克隆的声音说话。",
        "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！想来点茶吗？",
    speaker_ids['EN-BR'],
    'british.wav'
)

# 生成印度口音
model.tts_to_file(
    "Namaste！欢迎来到我们公司。",
    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"已生成 {len(texts)} 个文件，耗时 {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
              数量：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
              数量：1
              capabilities: [gpu]
```

### 显存需求总结

| 模型          | CPU     | 4GB GPU | 8GB GPU | 16GB GPU |
| ----------- | ------- | ------- | ------- | -------- |
| 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="你好，世界！这使用的是 OpenAI TTS API 格式。",
)
response.stream_to_file("output.mp3")
```

### LangChain 集成

```python
# 在 LangChain 中使用 TTS 构建语音代理
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（最适合中日韩）或 MeloTTS

仅英文，追求最高质量？
  → Kokoro（最佳体积/质量比）

需要 17 种以上语言？
  → XTTS v2

允许商业使用？
  → Kokoro（Apache）或 MeloTTS（MIT）或 Bark（MIT）

非商业研究？
  → 都可以（XTTS v2 CPML 或 Fish Speech CC BY-NC-SA）
```

### 按应用类型

| 应用      | 最佳选择                   | 原因            |
| ------- | ---------------------- | ------------- |
| 有声书生成   | XTTS v2                | 自然、一致的语音      |
| 实时聊天机器人 | MeloTTS or Kokoro      | 最快推理          |
| 播客自动化   | XTTS v2 or Fish Speech | 最佳克隆          |
| 游戏角色    | Bark                   | 富有表现力、变化丰富的语音 |
| 客户服务    | MeloTTS                | 可扩展、快速        |
| 无障碍工具   | Kokoro                 | 轻量、免费         |
| 语音配音    | Fish Speech            | 最佳克隆质量        |
| 长篇旁白    | XTTS v2                | 稳定的质量         |

***

## 许可证总结

{% hint style="warning" %}
**许可证对商业使用很重要！** 在生产环境部署前务必检查。
{% endhint %}

| 模型          | 许可证             | 商业用途？ | 备注        |
| ----------- | --------------- | ----- | --------- |
| XTTS v2     | Coqui 公共模型许可证   | ❌ 免费  | 商业用途需要许可证 |
| 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/月
  在 CPU 上可处理 100+ 并发请求

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** | 最佳中日韩支持，生产级克隆，非商业        |
| **MeloTTS**     | 最快、实时、多口音英文，MIT 许可证      |

对于大多数 Clore.ai 生产部署：

* **实时语音应用** → MeloTTS 或 Kokoro（免费、快速、MIT）
* **语音克隆服务** → XTTS v2 或 Fish Speech（检查许可证）
* **富有表现力的叙述** → Bark 或 XTTS v2

***

## Clore.ai GPU 推荐

| 使用场景  | 推荐 GPU         | Clore.ai 预计成本                     |
| ----- | -------------- | --------------------------------- |
| 开发/测试 | RTX 3090（24GB） | $0.07–0.21/gpu/hr                 |
| 生产环境  | RTX 4090（24GB） | $0.14–0.42/gpu/hr                 |
| 大规模   | A100 80GB      | [裸机](https://clore.ai/bare-metal) |

> 💡 本指南中的所有示例都可以部署在 [Clore.ai](https://clore.ai/marketplace) GPU 服务器上。浏览可用 GPU 并按小时租用——无需承诺，拥有完整 root 访问权限。


---

# 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-zh/dui-bi/tts-comparison.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.