TTS 大模型对比与分析#

1
2
3

from transformers import SpeechT5Processor, SpeechT5ForTextToSpeech

model = SpeechT5ForTextToSpeech.from_pretrained("microsoft/speecht5_tts")

1
2
3

from transformers import AutoProcessor, BarkModel

model = BarkModel.from_pretrained("suno/bark")

1
2
3
4
5

# 非语言声音
text = "[laughs] Ha ha! [sighs] Okay..."

# 唱歌
text = "♪ Twinkle twinkle little star ♪"

1
2
3
4

from TTS.api import TTS

tts = TTS("tts_models/en/ljspeech/vits")
tts.tts_to_file(text="Hello!", file_path="output.wav")

1
2
3
4

from tortoise.api import TextToSpeech

tts = TextToSpeech()
audio = tts.tts("Hello, this is Tortoise TTS.")

1
2
3
4
5
6
7
8
9

from openai import OpenAI

client = OpenAI()
response = client.audio.speech.create(
    model="tts-1-hd",
    voice="alloy",
    input="Hello, this is OpenAI TTS."
)
response.stream_to_file("output.mp3")

1
2
3
4
5
6
7
8

from elevenlabs import generate, set_api_key

set_api_key("your-api-key")
audio = generate(
    text="Hello, this is ElevenLabs.",
    voice="Rachel",
    model="eleven_multilingual_v2"
)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

import azure.cognitiveservices.speech as speechsdk

speech_config = speechsdk.SpeechConfig(
    subscription="key",
    region="region"
)
speech_config.speech_synthesis_voice_name = "zh-CN-XiaoxiaoNeural"

synthesizer = speechsdk.SpeechSynthesizer(speech_config=speech_config)
result = synthesizer.speak_text_async("你好世界").get()

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

import edge_tts
import asyncio

async def synthesize():
    communicate = edge_tts.Communicate(
        "Hello, this is Edge TTS.",
        "en-US-JennyNeural"
    )
    await communicate.save("output.mp3")

asyncio.run(synthesize())

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57

"""TTS 快速开始模板"""

from abc import ABC, abstractmethod

class TTSProvider(ABC):
    @abstractmethod
    def synthesize(self, text: str) -> bytes:
        pass

class EdgeTTSProvider(TTSProvider):
    def __init__(self, voice="zh-CN-XiaoxiaoNeural"):
        self.voice = voice

    async def synthesize(self, text: str) -> bytes:
        import edge_tts
        communicate = edge_tts.Communicate(text, self.voice)
        audio_data = b""
        async for chunk in communicate.stream():
            if chunk["type"] == "audio":
                audio_data += chunk["data"]
        return audio_data

class OpenAITTSProvider(TTSProvider):
    def __init__(self, voice="alloy"):
        from openai import OpenAI
        self.client = OpenAI()
        self.voice = voice

    def synthesize(self, text: str) -> bytes:
        response = self.client.audio.speech.create(
            model="tts-1",
            voice=self.voice,
            input=text
        )
        return response.content

class BarkTTSProvider(TTSProvider):
    def __init__(self):
        from transformers import pipeline
        self.tts = pipeline("text-to-speech", model="suno/bark-small")

    def synthesize(self, text: str) -> bytes:
        import soundfile as sf
        import io
        speech = self.tts(text)
        buffer = io.BytesIO()
        sf.write(buffer, speech["audio"], samplerate=speech["sampling_rate"], format="WAV")
        return buffer.getvalue()

# 使用
def get_tts_provider(provider_name: str) -> TTSProvider:
    providers = {
        "edge": EdgeTTSProvider,
        "openai": OpenAITTSProvider,
        "bark": BarkTTSProvider,
    }
    return providers[provider_name]()

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

"""TTS 质量测试"""

import time

def benchmark_tts(provider, text, iterations=5):
    """测试 TTS 性能"""
    times = []

    for _ in range(iterations):
        start = time.time()
        audio = provider.synthesize(text)
        elapsed = time.time() - start
        times.append(elapsed)

    return {
        "avg_time": sum(times) / len(times),
        "min_time": min(times),
        "max_time": max(times),
        "audio_size": len(audio)
    }

# 测试文本
test_texts = {
    "short": "Hello, world!",
    "medium": "Welcome to our text to speech system. We hope you enjoy using it.",
    "long": "..." # 长文本
}

# 运行测试
for name, text in test_texts.items():
    result = benchmark_tts(provider, text)
    print(f"{name}: {result}")