# 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 访问权限。