# 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="Hello, this is a cloned voice speaking naturally.",
    speaker_wav="reference_voice.wav",
    language="en",
    file_path="output.wav"
)
```

### Bark

Suno 的 Bark 是基于变换器的 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] Hello! [clears throat] This is Bark TTS. [sighs]"
)
write_wav("output.wav", SAMPLE_RATE, audio_array)
```

### Kokoro

Kokoro 是一个轻量、快速的 TTS 模型，针对英语进行了优化。尽管体积小（约 82M 参数），但提供了出乎意料的高质量。

**理念**：小模型，大质量，可在任何地方运行。

```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，能从短片段进行出色的语音克隆。它使用新颖的编码器 + 语言模型架构。

**理念**：生产级质量，快速推理，出色的克隆能力。

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

response = requests.post(
    "http://localhost:8080/v1/tts",
    json={
        "text": "Hello, this is Fish Speech generating audio.",
        "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(
    "Hello world! MeloTTS is very fast.",
    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 vs 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 秒     | ≈2 秒     |
| Fish Speech | ≈45 秒    | ≈8 秒     | ≈3 秒     |
| MeloTTS     | **≈8 秒** | **≈2 秒** | **<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="""
    欢迎收听我们的播客。今天我们讨论人工智能的未来 
    及其对社会的影响。我是你的主持人，很高兴 
    与您分享一些有趣的见解。
    """,
    speaker_wav="speaker_sample.wav",  # 你的参考音频
    language="en",
    file_path="cloned_voice_output.wav"
)
```

### Fish Speech 语音克隆

```bash
# 从参考音频克隆
fish_speech_cli tts \
  --text "This is my cloned voice speaking a new sentence." \
  --reference-audio speaker_sample.wav \
  --reference-text "The original text spoken in the reference audio." \
  --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(
    "Welcome! [laughs] This is absolutely fascinating technology.",
    history_prompt=voice_presets["female_US"]
)
write("bark_output.wav", SAMPLE_RATE, audio)
```

***

## XTTS v2：深入解析

### 架构

* **VITS + GPT** 混合架构
* 在 17 种语言上训练超过 16K 小时
* 零样本克隆最低需 3 秒

### 在 Clore.ai 上的安装

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

### Docker 部署

```dockerfile
FROM nvidia/cuda:12.1.0-cudnn8-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 的变换器** 用于音频令牌生成
* 三阶段流程：文本 → 语义 → 粗粒度 → 细粒度令牌
* 生成实际的音频编码器令牌（EnCodec）

### 使 Bark 独特的点

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

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

### 标记语言

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

# 用于表现力的特殊标记
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：深入解析

### 架构

* **82M 参数** 基于 StyleTTS2 的模型
* 极小但质量令人惊讶地高
* 在 CPU 和 GPU 上都能快速推理

### 可用语音

```python
from kokoro import KPipeline

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

# 可用语音
voices = {
    'af_heart': '美式女性（温暖）',
    'af_bella': '美式女性（bella）',
    'af_nicole': '美式女性（nicole）',
    'am_michael': '美式男性（michael）',
    'am_fenrir': '美式男性（fenrir）',
    'bf_emma': '英式女性（emma）',
    'bm_george': '英式男性（george）',
}

# 使用不同语音生成
for voice_name, description in voices.items():
    gen = pipeline("Hello, this is a test.", voice=voice_name)
    for _, _, audio in gen:
        print(f"Generated with {description}")
```

### 流式支持

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

pipeline = KPipeline(lang_code='a')

# 在生成时实时流式输出音频
text = "This is a very long text that will be streamed as it generates, providing low-latency audio output."

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

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

***

## Fish Speech：深入解析

### 架构

* **VQGAN + 语言模型** 架构
* 在 700K+ 小时音频上训练
* 强大的多语言能力，支持亚洲语言

### 安装

```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
BASE_URL = "http://localhost:9090"  # 或您的 CLORE.AI http_pub URL

# 通过 HTTP API
with httpx.Client() as client:
    response = client.post(
        "http://localhost:8080/v1/tts",
        json={
            "text": "Hello from Fish Speech! This sounds very natural.",
            "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": "The text spoken in this recording."}
    )
    voice_id = response.json()["id"]

# 使用克隆语音
response = httpx.post(
    "http://localhost:8080/v1/tts",
    json={
        "text": "Now speaking in the cloned voice.",
        "reference_id": voice_id,
    }
)
```

**弱点**：CC BY-NC-SA 许可（非商业），为获得最佳质量需较高显存

***

## 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! Fancy a spot of tea?",
    speaker_ids['EN-BR'],
    'british.wav'
)

# 使用印度口音生成
model.tts_to_file(
    "Namaste! Welcome to our company.",
    speaker_ids['EN-INDIA'],
    'indian.wav'
)
```

### 批处理（非常快）

```python
from melo.api import TTS
import base64

model = TTS(language='EN', device='cuda')
sid = model.hps.data.spk2id['EN-Default']

texts = [
    "First sentence to synthesize.",
    "Second sentence goes here.",
    "Third and final sentence.",
]

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"Generated {len(texts)} files in {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
              count: 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
              count: 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="Hello world! This uses the OpenAI TTS API format.",
)
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 或 Kokoro      | 最快的推理速度     |
| 播客自动化   | XTTS v2 或 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 建议

| 在 Clore.ai 上的预估费用 | 开发/测试             | RTX 3090（24GB） |
| ----------------- | ----------------- | -------------- |
| \~$0.12/每 GPU/每小时 | 生产                | RTX 4090（24GB） |
| \~$0.70/每 GPU/每小时 | 大规模               | A100 80GB      |
| \~$1.20/每 GPU/每小时 | 💡 本指南中的所有示例均可部署在 | Clore.ai       |

> GPU 服务器上。浏览可用 GPU 并按小时租用 — 无需承诺，提供完整的 root 访问权限。 [Clore.ai](https://clore.ai/marketplace) GPU 服务器。浏览可用 GPU 并按小时租用 — 无需承诺，提供完整的 root 访问权限。


---

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