1
# 如果双击无反应，可以右键 "go-webui.bat" -> 以管理员身份运行
2

3
# 或者使用 PowerShell
4
.\go-webui.bat

1
Running on local URL: http://127.0.0.1:7860

1
GPT-SoVITS/
2
├── GPT_SoVITS/
3
│   └── pretrained_models/     # 放入主模型
4
│   └── text/
5
│       └── G2PWModel/        # 放入中文 G2PW 模型
6
├── tools/
7
│   ├── uvr5/
8
│   │   └── uvr5_weights/     # 放入 UVR5 模型
9
│   └── asr/
10
│       └── models/           # 放入 ASR 模型

1
你好，我叫张三，今天天气真不错。
2
一二三四五六七八九十。
3
今天是 2024 年 3 月 15 日，星期三。
4
北京是中国的首都，上海是金融中心。
5
人工智能技术正在改变世界。
6
机器学习是人工智能的核心分支。
7
请帮我查询明天的天气情况。
8
很高兴认识你，我们做朋友吧。
9
床前明月光，疑是地上霜。举头望明月，低头思故乡。
10
人工智能助手可以帮你完成很多任务。

1
操作步骤：
2
1. 输入原始音频路径（或文件夹路径）
3
2. 设置输出目录
4
3. 调整参数：
5
   - 阈值（threshold）：音量阈值，建议 -30 到 -40
6
   - 最小长度（min_length）：每个切片最小时长，建议 3-5 秒
7
   - 最小间隔（min_interval）：相邻切片最小间隔，建议 0.1-0.3 秒
8
4. 点击「开始处理」

1
操作步骤：
2
1. 选择语言：中文 -> FunASR；英文 / 日文 -> Faster Whisper
3
2. 输入处理后的音频目录路径
4
3. 设置输出目录
5
4. 点击「开始运行」

1
D:\GPT-SoVITS\dataset\processed\audio_001.wav|myvoice|zh|你好，我叫张三，今天天气真不错。
2
D:\GPT-SoVITS\dataset\processed\audio_002.wav|myvoice|zh|一二三四五六七八九十。

1
# 训练数据目录
2
训练数据集路径：dataset/processed/
3

4
# 实验 / 模型名称（自定义）
5
实验名称：my-voice-v4
6

7
# 音频设置
8
采样率：16000

1
操作步骤：
2
1. 确认参数配置无误
3
2. 点击「开始训练 SoVITS」按钮
4
3. 等待 SoVITS 训练完成（约 10-20 分钟）
5
4. SoVITS 训练完成后，点击「开始训练 GPT」按钮
6
5. 等待 GPT 训练完成（约 10-30 分钟）
7
6. 训练完成后，模型自动保存在输出目录

1
GPT-SoVITS/
2
├── output/
3
│   └── my-voice-v4/
4
│       ├── SoVITS/
5
│       │   └── s1v4_e100_*.pth    # SoVITS 模型
6
│       └── GPT/
7
│           └── s2v4_e100_*.pth   # GPT 模型

1
操作步骤：
2
1. 在「模型路径」区域：
3
   - SoVITS 模型：选择 output/my-voice-v4/SoVITS/*.pth
4
   - GPT 模型：选择 output/my-voice-v4/GPT/*.pth
5
2. 点击「加载模型」按钮
6
3. 等待模型加载完成

1
操作步骤：
2
1. 上传参考音频：
3
   - 点击「上传参考音频」按钮
4
   - 选择一个包含你声音的音频文件（3-10 秒最佳）
5
2. 输入要生成的文本：
6
   你好，这是使用我的声音生成的语音。
7
3. 调整参数：
8
   - top_k：5-15（控制生成多样性）
9
   - top_p：0.8-1.0
10
   - temperature：0.8-1.2（控制随机性）
11
   - 语速：1.0（标准）
12
4. 点击「开始生成」按钮
13
5. 等待生成完成，播放或下载音频

1
#!/usr/bin/env python3
2
"""
3
GPT-SoVITS TTS API 服务
4
将语音模型部署为 HTTP API，供 AI Agent 调用
5

6
注意：此脚本需要 GPT-SoVITS 的推理能力支持
7
完整实现需要参考 GPT-SoVITS 源码进行适配
8
"""
9

10
import io
11
import base64
12
import tempfile
13
import torch
14
import soundfile as sf
15
from flask import Flask, request, send_file, jsonify
16
from pathlib import Path
17

18
# ========== 配置区 ==========
19
HOST = "0.0.0.0"
20
PORT = 5002
21
SAMPLE_RATE = 24000  # GPT-SoVITS 输出采样率
22
# ============================
23

24
app = Flask(__name__)
25

26
# 导入 GPT-SoVITS 推理模块
27
try:
28
    import sys
29
    sys.path.insert(0, ".")
30
    from GPT_SoVITS.inference_webui import GPTSoVITS
31
    MODEL_LOADED = True
32
except Exception as e:
33
    print(f"警告：无法加载 GPT-SoVITS 推理模块: {e}")
34
    MODEL_LOADED = False
35

36
gpt_sovits = None
37

38
def init_model():
39
    """初始化模型"""
40
    global gpt_sovits
41
    if not MODEL_LOADED:
42
        return
43

44
    print("加载 GPT-SoVITS 模型...")
45
    try:
46
        # 加载训练好的模型
47
        gpt_sovits = GPTSoVITS(
48
            device="cuda" if torch.cuda.is_available() else "cpu"
49
        )
50
        print("模型加载完成")
51
    except Exception as e:
52
        print(f"模型加载失败: {e}")
53

54
@app.route("/health", methods=["GET"])
55
def health_check():
56
    """健康检查"""
57
    return jsonify({
58
        "status": "ok" if MODEL_LOADED else "model_not_loaded",
59
        "model_loaded": MODEL_LOADED,
60
        "cuda_available": torch.cuda.is_available()
61
    })
62

63
@app.route("/tts", methods=["POST"])
64
def text_to_speech():
65
    """
66
    文本转语音接口
67

68
    请求参数 (JSON):
69
        text: str - 要转换的文本
70
        reference_audio: str - 参考音频路径（可选）
71
    """
72
    try:
73
        if not MODEL_LOADED or gpt_sovits is None:
74
            return jsonify({"error": "模型未加载"}), 500
75

76
        data = request.get_json()
77
        if not data or "text" not in data:
78
            return jsonify({"error": "缺少 text 参数"}), 400
79

80
        text = data["text"]
81
        reference_audio = data.get("reference_audio")
82

83
        print(f"生成语音: {text[:50]}...")
84

85
        # 生成语音
86
        # 注意：具体 API 调用需要参考 GPT-SoVITS 源码
87
        # audio = gpt_sovits.generate(
88
        #     text=text,
89
        #     reference_audio=reference_audio
90
        # )
91

92
        # 临时返回错误，实际使用时需要正确实现
93
        return jsonify({"error": "请使用 WebUI 进行推理"}), 501
94

95
    except Exception as e:
96
        import traceback
97
        traceback.print_exc()
98
        return jsonify({"error": str(e)}), 500
99

100
@app.route("/tts_base64", methods=["POST"])
101
def text_to_speech_base64():
102
    """返回 Base64 编码的音频"""
103
    try:
104
        data = request.get_json()
105
        if not data or "text" not in data:
106
            return jsonify({"error": "缺少 text 参数"}), 400
107

108
        text = data["text"]
109

110
        # 实际使用时需要调用模型生成
111
        # 这里返回示例结构
112
        return jsonify({
113
            "error": "请使用 WebUI 进行推理"
114
        }), 501
115

116
    except Exception as e:
117
        return jsonify({"error": str(e)}), 500
118

119
def main():
120
    """启动服务"""
121
    init_model()
122

123
    print(f"\n{'='*50}")
124
    print(f"GPT-SoVITS API 服务")
125
    print(f"注意：建议直接使用 WebUI 进行推理")
126
    print(f"地址: http://{HOST}:{PORT}")
127
    print(f"{'='*50}\n")
128

129
    app.run(host=HOST, port=PORT, debug=False, threaded=True)
130

131
if __name__ == "__main__":
132
    main()

1
import requests
2
import io
3
import soundfile as sf
4

5
# 先调用 TTS 接口
6
response = requests.post(
7
    "http://localhost:9876/tts",
8
    json={
9
        "text": "你好，这是使用我的声音生成的语音。",
10
        "ref_audio_path": "dataset/processed/ref.wav",
11
        "prompt_text": "你好，这是参考音频。",
12
        "prompt_lang": "zh",
13
        "text_lang": "zh"
14
    }
15
)
16

17
# 保存音频
18
if response.status_code == 200:
19
    audio_data = response.content
20
    # 音频为 24kHz WAV 格式
21
    with open("output.wav", "wb") as f:
22
        f.write(audio_data)

1
import requests
2

3
# 调用本地 WebUI（如果 WebUI 开启了 API 功能）
4
response = requests.post(
5
    "http://localhost:7860/api/v1/tts",
6
    json={
7
        "text": "你好，这是测试语音",
8
        "reference_audio": "path/to/ref.wav"
9
    }
10
)

1
┌─────────────┐     HTTP      ┌─────────────┐     音频流     ┌─────────────┐
2
│  AI Agent   │ ────────────> │   TTS API   │ ─────────────> │   用户播放   │
3
│  ( 任意平台 )  │   JSON 请求   │  (GPT-SoVITS)│               │             │
4
└─────────────┘               └─────────────┘               └─────────────┘

1
import requests
2
import base64
3

4
def tts_generate(text, ref_audio, api_url="http://localhost:9876"):
5
    """调用 GPT-SoVITS API 生成语音"""
6
    response = requests.post(
7
        f"{api_url}/tts",
8
        json={
9
            "text": text,
10
            "ref_audio_path": ref_audio,
11
            "prompt_text": "你好。",  # 参考音频对应的文本
12
            "prompt_lang": "zh",
13
            "text_lang": "zh"
14
        }
15
    )
16
    return response.content  # 返回 WAV 音频数据
17

18
# AI Agent 中调用
19
audio_bytes = tts_generate(
20
    text="今天天气真不错，我们出去散步吧。",
21
    ref_audio="dataset/processed/ref.wav"
22
)

1
#!/usr/bin/env python3
2
"""启动 GPT-SoVITS TTS API 服务"""
3
import subprocess
4
import sys
5
import os
6

7
# 设置工作目录
8
os.chdir(os.path.dirname(os.path.abspath(__file__)))
9

10
# 启动 API 服务
11
print("启动 GPT-SoVITS API 服务...")
12
print("API 地址: http://localhost:9876")
13
print("按 Ctrl+C 停止服务\n")
14

15
subprocess.run([
16
    sys.executable, "GPT_SoVITS/api.py"
17
])

1
#!/usr/bin/env python3
2
"""GPT-SoVITS TTS 客户端封装"""
3
import requests
4
import base64
5
import io
6
import soundfile as sf
7
from typing import Optional
8

9
class GPTSoVITSClient:
10
    def __init__(self, api_url: str = "http://localhost:9876"):
11
        self.api_url = api_url
12
        self.ref_audio = None
13
        self.prompt_text = None
14

15
    def set_reference(self, ref_audio_path: str, prompt_text: str):
16
        """设置参考音频和对应文本"""
17
        self.ref_audio = ref_audio_path
18
        self.prompt_text = prompt_text
19

20
    def generate(self, text: str, language: str = "zh") -> bytes:
21
        """生成语音"""
22
        if not self.ref_audio:
23
            raise ValueError("请先设置参考音频 (set_reference)")
24

25
        response = requests.post(
26
            f"{self.api_url}/tts",
27
            json={
28
                "text": text,
29
                "ref_audio_path": self.ref_audio,
30
                "prompt_text": self.prompt_text,
31
                "prompt_lang": language,
32
                "text_lang": language
33
            },
34
            timeout=60
35
        )
36

37
        if response.status_code != 200:
38
            raise Exception(f"TTS 生成失败: {response.text}")
39

40
        return response.content
41

42
    def generate_to_file(self, text: str, output_path: str, language: str = "zh"):
43
        """生成语音并保存到文件"""
44
        audio_data = self.generate(text, language)
45
        with open(output_path, "wb") as f:
46
            f.write(audio_data)
47
        return output_path
48

49

50
# ========== 独立使用示例 ==========
51
if __name__ == "__main__":
52
    client = GPTSoVITSClient()
53

54
    # 设置参考音频
55
    client.set_reference(
56
        ref_audio_path="dataset/processed/ref.wav",
57
        prompt_text="你好，这是参考音频。"
58
    )
59

60
    # 生成语音
61
    print("生成语音...")
62
    audio = client.generate("你好，今天我们来进行一个简单的对话。")
63
    print(f"生成成功，音频大小: {len(audio)} bytes")
64

65
    # 保存到文件
66
    client.generate_to_file(
67
        "今天天气真不错。",
68
        "output.wav"
69
    )
70
    print("已保存到 output.wav")

1
#!/usr/bin/env python3
2
"""AI Agent + GPT-SoVITS 集成示例"""
3
from tts_client import GPTSoVITSClient
4
import asyncio
5

6
class VoiceAgent:
7
    def __init__(self):
8
        self.tts = GPTSoVITSClient()
9
        # 初始化时设置声音
10
        self.tts.set_reference(
11
            ref_audio_path="dataset/processed/ref.wav",
12
            prompt_text="你好，我是你的语音助手。"
13
        )
14

15
    def chat(self, user_input: str) -> str:
16
        """处理用户输入并返回文本回复"""
17
        # 这里接入你的 AI 对话逻辑
18
        # 例如：Claude API、ChatGPT、本地模型等
19
        ai_response = f"你说了: {user_input}，这是 AI 的回复。"
20
        return ai_response
21

22
    def voice_chat(self, user_input: str) -> bytes:
23
        """语音对话：输入文本，返回语音"""
24
        # 1. AI 生成回复
25
        response_text = self.chat(user_input)
26

27
        # 2. TTS 转换
28
        audio = self.tts.generate(response_text)
29

30
        return audio
31

32

33
# ========== 使用示例 ==========
34
if __name__ == "__main__":
35
    agent = VoiceAgent()
36

37
    # 文字对话
38
    response = agent.chat("今天天气怎么样？")
39
    print(f"AI: {response}")
40

41
    # 语音对话
42
    audio = agent.voice_chat("今天天气怎么样？")
43
    print(f"语音已生成，音频大小: {len(audio)} bytes")

1
#!/usr/bin/env python3
2
"""流式语音生成 Agent"""
3
import requests
4
import io
5
import soundfile as sf
6
from tts_client import GPTSoVITSClient
7

8
class StreamingVoiceAgent:
9
    def __init__(self):
10
        self.tts = GPTSoVITSClient()
11
        self.tts.set_reference(
12
            ref_audio_path="dataset/processed/ref.wav",
13
            prompt_text="你好。"
14
        )
15

16
    def stream_voice(self, text_segments: list):
17
        """流式生成语音（分段处理）"""
18
        for segment in text_segments:
19
            print(f"处理: {segment}")
20
            audio = self.tts.generate(segment)
21
            yield audio
22
            # 此处可添加实时播放逻辑
23

24
# 使用方式
25
agent = StreamingVoiceAgent()
26

27
# 分段处理长文本
28
long_text = "今天天气真不错。我们出去散步吧。首先去公园，然后去超市买点东西。"
29
segments = long_text.split("。")  # 按句子分割
30

31
for i, audio_chunk in enumerate(agent.stream_voice(segments)):
32
    print(f"第 {i+1} 段音频生成完成")
33
    # 可以实时播放或保存

1
#!/usr/bin/env python3
2
"""WebSocket TTS 服务（需要额外配置）"""
3
# 注意：GPT-SoVITS 原生不支持 WebSocket
4
# 如需此功能，可通过以下方式实现：
5

6
# 使用 Flask-SocketIO 或 FastAPI WebSocket
7
# 在前端使用 Audio API 实时播放
8

9
# 示例架构：
10
# 前端 --WebSocket--> Agent Server --HTTP--> GPT-SoVITS API ---> 音频流

1
import openai  # 或 anthropic
2

3
def ai_agent_voice(user_text, voice_client):
4
    """调用大模型后用 TTS 生成语音"""
5

6
    # 1. 调用大模型获取回复
7
    response = openai.ChatCompletion.create(
8
        model="gpt-4",
9
        messages=[{"role": "user", "content": user_text}]
10
    )
11
    reply = response.choices[0].message.content
12

13
    # 2. 调用 TTS 生成语音
14
    audio = voice_client.generate(reply)
15

16
    return audio, reply

1
def rag_voice_agent(user_query, knowledge_base, voice_client):
2
    """基于知识库的语音问答"""
3

4
    # 1. 知识库检索
5
    context = knowledge_base.search(user_query)
6

7
    # 2. 构建提示
8
    prompt = f"基于以下信息回答：\n{context}\n\n 问题：{user_query}"
9

10
    # 3. 调用大模型
11
    response = llm.generate(prompt)
12

13
    # 4. TTS 生成
14
    audio = voice_client.generate(response)
15

16
    return audio, response

1
#!/usr/bin/env python3
2
"""
3
文件监听 TTS 方案
4
监听指定文件，当文件内容变化时自动生成语音并播放
5

6
适用于：
7
- AI Agent 输出文本后自动朗读
8
- 无人值守的语音播报场景
9
"""
10

11
import time
12
import os
13
import subprocess
14
from pathlib import Path
15

16
# ========== 配置区 ==========
17
# 监听的文件路径（AI Agent 向此文件写入文本）
18
WATCH_FILE = "agent_output.txt"
19

20
# 参考音频路径
21
REFERENCE_AUDIO = "dataset/processed/ref.wav"
22

23
# WebUI 是否运行
24
WEBUI_URL = "http://localhost:7860"
25

26
# 检查间隔（秒）
27
CHECK_INTERVAL = 1.0
28
# ============================
29

30
def get_last_text():
31
    """读取文件内容"""
32
    try:
33
        with open(WATCH_FILE, "r", encoding="utf-8") as f:
34
            return f.read().strip()
35
    except:
36
        return ""
37

38
def generate_speech(text):
39
    """生成语音"""
40
    if not text:
41
        return
42

43
    print(f"生成语音: {text[:50]}...")
44

45
    # 方式 1：调用 WebUI API（如可用）
46
    try:
47
        import requests
48
        response = requests.post(
49
            f"{WEBUI_URL}/api/v1/tts",
50
            json={
51
                "text": text,
52
                "reference_audio": REFERENCE_AUDIO
53
            },
54
            timeout=30
55
        )
56
        if response.status_code == 200:
57
            print("生成成功")
58
            return
59
    except:
60
        pass
61

62
    # 方式 2：打开 WebUI 手动处理
63
    print("请在 WebUI 中手动生成语音")
64
    print(f"文本: {text}")
65

66
def play_audio():
67
    """播放音频"""
68
    # 查找最新生成的音频文件
69
    output_dir = Path("output/audio")
70
    if not output_dir.exists():
71
        return
72

73
    audio_files = list(output_dir.glob("*.wav"))
74
    if not audio_files:
75
        return
76

77
    latest = max(audio_files, key=lambda p: p.stat().st_mtime)
78

79
    # 播放
80
    try:
81
        # Windows
82
        subprocess.run(["start", str(latest)], shell=True)
83
    except:
84
        try:
85
            # Linux
86
            subprocess.run(["aplay", str(latest)])
87
        except:
88
            print(f"请手动播放: {latest}")
89

90
def main():
91
    """主函数"""
92
    print(f"监听文件: {WATCH_FILE}")
93
    print(f"检查间隔: {CHECK_INTERVAL} 秒")
94
    print("按 Ctrl+C 退出\n")
95

96
    last_content = ""
97

98
    while True:
99
        current_content = get_last_text()
100

101
        if current_content and current_content != last_content:
102
            print(f"\n 检测到新内容: {current_content[:50]}...")
103
            generate_speech(current_content)
104
            last_content = current_content
105

106
        time.sleep(CHECK_INTERVAL)
107

108
if __name__ == "__main__":
109
    main()