TTS 引擎比较

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

文本转语音（TTS） 将书面文本转换为自然听感的音频。本指南比较五款领先的开源 TTS 引擎：XTTS v2、Bark、Kokoro、Fish Speech 和 MeloTTS —— 涵盖质量、速度、语言支持和语音克隆能力。

---

快速决策矩阵

	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 秒音频片段中克隆任何声音，保真度极高。

理念：最大化表现力和语音克隆质量。

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 模型，能生成高度富有表现力的语音，包括非语音音效：笑声、叹息、音乐和音效。

理念：不仅是语音——完整的音频生成。

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 参数），但提供了出乎意料的高质量。

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

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

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

# 通过 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 上运行高效，并支持多种英语口音和亚洲语言。

理念：在任何规模上实现实时速度。

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）

MOS 分数是基于已发表论文和社区评估的近似值。实际质量在很大程度上取决于文本内容和语音配置。

模型	英语 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 秒

对于实时应用：MeloTTS 和 Kokoro 明显胜出。两者即使在 CPU 上也能生成比回放速度更快的语音。

---

语言支持

支持语言

模型	语言	值得注意的
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	快速	快速	快速	快速

针对中文 TTS：Fish Speech 和 MeloTTS 是最佳的开源选项。两者都能自然处理声调和字符。

针对多语言应用：XTTS v2 支持最多的语言，并在所有语言上保持一致的质量。

---

语音克隆对比

克隆能力

模型	参考长度	克隆质量	零样本
XTTS v2	3 秒	⭐⭐⭐⭐⭐	✅
Bark	仅语音预设	⭐⭐⭐	部分支持
Kokoro	不支持	❌	❌
Fish Speech	10 秒	⭐⭐⭐⭐⭐	✅
MeloTTS	不支持	❌	❌

XTTS v2 语音克隆

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 语音克隆

# 从参考音频克隆
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 语音预设

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 上的安装

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

Docker 部署

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"]

# 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")

docker build -t xtts-server .
docker run -d --gpus all -p 5002:5002 xtts-server

弱点：CPML 许可证（非商业需获许可），比 Kokoro/MeloTTS 更慢

---

Bark：深入解析

架构

• 类 GPT 的变换器 用于音频令牌生成

• 三阶段流程：文本 → 语义 → 粗粒度 → 细粒度令牌

• 生成实际的音频编码器令牌（EnCodec）

使 Bark 独特的点

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

• 🎵 在语音中加入背景音乐

• 😂 笑声、叹息、清嗓音

• 🎭 在一次生成中包含多位说话人

• 🌍 混合语言的语句

标记语言

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)

安装

pip install git+https://github.com/suno-ai/bark.git

弱点：慢（3 阶段流水线）、运行间表现不一致、不支持真正的语音克隆

---

Kokoro：深入解析

架构

• 82M 参数 基于 StyleTTS2 的模型

• 极小但质量令人惊讶地高

• 在 CPU 和 GPU 上都能快速推理

可用语音

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}")

流式支持

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+ 小时音频上训练

• 强大的多语言能力，支持亚洲语言

安装

pip install fish-speech

# 或通过 Docker
docker run -d \
  --gpus all \
  -p 8080:8080 \
  fishaudio/fish-speech:latest \
  +api_server.workers_count=1

Python API

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)

语音克隆

# 上传参考，获取语音 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 架构

• 多口音英语训练

• 为推理速度进行了极度优化

口音与语言

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'
)

批处理（非常快）

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 服务器

# 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（用于替换）

# 许多 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 集成

# 在 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	一致的质量

---

许可摘要

许可对商业使用很重要！ 在生产环境部署前务必检查。

模型	许可	商业用途？	说明
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） — 35K+ 星标

• Bark GitHub — 38K+ 星标

• Kokoro GitHub — 12K+ 星标

• Fish Speech GitHub — 14K+ 星标

• MeloTTS GitHub — 15K+ 星标

• 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 GPU 服务器。浏览可用 GPU 并按小时租用 — 无需承诺，提供完整的 root 访问权限。