gpt-sovits-sdk
Version:
Node.js SDK for GPT-SoVITS API
259 lines (258 loc) • 9.92 kB
JavaScript
;
/**
* GPT-SoVITS SDK 模型配对示例
*
* 这个示例展示了如何使用SDK进行模型配对操作，包括：
* 1. 获取所有可用模型
* 2. 自动配对GPT和SoVITS模型
* 3. 使用配对的模型进行TTS
*/
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
var desc = Object.getOwnPropertyDescriptor(m, k);
if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
desc = { enumerable: true, get: function() { return m[k]; } };
}
Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
o["default"] = v;
});
var __importStar = (this && this.__importStar) || (function () {
var ownKeys = function(o) {
ownKeys = Object.getOwnPropertyNames || function (o) {
var ar = [];
for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
return ar;
};
return ownKeys(o);
};
return function (mod) {
if (mod && mod.__esModule) return mod;
var result = {};
if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
__setModuleDefault(result, mod);
return result;
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
const index_1 = require("../index");
const path = __importStar(require("path"));
const fs = __importStar(require("fs"));
// 创建输出目录
const outputDir = path.join(__dirname, '../../output');
if (!fs.existsSync(outputDir)) {
fs.mkdirSync(outputDir, { recursive: true });
}
// 创建客户端实例
const client = (0, index_1.createClient)({
baseUrl: 'http://127.0.0.1:9880',
timeout: 60000,
debug: true
});
/**
* 获取所有可用模型并进行配对
*/
async function getModelPairs() {
console.log('获取所有可用模型...');
const modelsResponse = await client.getModels();
if (!modelsResponse.data) {
console.log('无法获取模型数据');
return [];
}
const { gpt_models, sovits_models } = modelsResponse.data;
console.log(`找到 ${gpt_models.length} 个GPT模型和 ${sovits_models.length} 个SoVITS模型`);
// 尝试自动配对模型
const pairs = [];
// 基于名称相似度进行配对
for (const gptModel of gpt_models) {
// 提取GPT模型名称的基本部分（去除后缀和版本号）
const gptBaseName = gptModel.name.replace(/\.ckpt$|\.pth$|-e\d+$|-epoch\d+$/, '');
// 查找匹配的SoVITS模型
const matchingSovitsModels = sovits_models.filter((sovitsModel) => {
const sovitsBaseName = sovitsModel.name.replace(/\.ckpt$|\.pth$|-e\d+$|-epoch\d+$/, '');
return sovitsBaseName === gptBaseName ||
sovitsBaseName.includes(gptBaseName) ||
gptBaseName.includes(sovitsBaseName);
});
if (matchingSovitsModels.length > 0) {
// 使用最匹配的SoVITS模型
pairs.push({
name: gptBaseName,
gptModel,
sovitsModel: matchingSovitsModels[0]
});
}
}
console.log(`自动配对了 ${pairs.length} 对模型`);
pairs.forEach((pair, index) => {
console.log(`配对 ${index + 1}: ${pair.name}`);
console.log(` GPT: ${pair.gptModel.path}`);
console.log(` SoVITS: ${pair.sovitsModel.path}`);
});
return pairs;
}
/**
* 使用配对的模型进行TTS
*/
async function testModelPairs(pairs) {
if (pairs.length === 0) {
console.log('没有找到配对的模型，无法进行测试');
return;
}
// 获取参考音频
console.log('\n获取参考音频...');
const referenceAudiosResponse = await client.getReferenceAudios();
if (!referenceAudiosResponse.data || referenceAudiosResponse.data.audios.length === 0) {
console.log('没有找到参考音频，无法进行测试');
return;
}
// 选择第一个参考音频
const refAudio = referenceAudiosResponse.data.audios[0];
console.log(`选择参考音频: ${refAudio.name}`);
// 测试文本
const testText = '这是一个模型配对测试，使用不同的模型生成语音。';
// 对每对模型进行测试
for (let i = 0; i < Math.min(pairs.length, 3); i++) { // 最多测试3对模型
const pair = pairs[i];
console.log(`\n测试模型配对 ${i + 1}: ${pair.name}`);
try {
// 设置模型
await client.setGptModel(pair.gptModel.path);
await client.setSovitsModel(pair.sovitsModel.path);
// 执行TTS
console.log(`使用模型 ${pair.name} 生成语音...`);
const result = await client.textToSpeechDirect({
text: testText,
textLang: index_1.TextLanguage.CHINESE,
refAudioPath: refAudio.path,
promptLang: index_1.TextLanguage.CHINESE,
mediaType: index_1.MediaType.WAV
}, path.join(outputDir, `model_pair_${pair.name}_${Date.now()}.wav`));
console.log(`模型 ${pair.name} 语音生成成功: ${result}`);
}
catch (error) {
console.error(`模型 ${pair.name} 测试失败:`, error);
}
}
}
/**
* 批量处理多个文本
*/
async function batchProcess(modelPair, texts, refAudioPath) {
console.log(`\n使用模型 ${modelPair.name} 批量处理 ${texts.length} 个文本...`);
// 设置模型
await client.setGptModel(modelPair.gptModel.path);
await client.setSovitsModel(modelPair.sovitsModel.path);
// 批量处理
for (let i = 0; i < texts.length; i++) {
const text = texts[i];
console.log(`处理文本 ${i + 1}/${texts.length}: ${text.substring(0, 30)}...`);
try {
const outputPath = path.join(outputDir, `batch_${modelPair.name}_${i + 1}_${Date.now()}.wav`);
await client.textToSpeechDirect({
text,
textLang: index_1.TextLanguage.CHINESE,
refAudioPath,
promptLang: index_1.TextLanguage.CHINESE,
mediaType: index_1.MediaType.WAV
}, outputPath);
console.log(`文本 ${i + 1} 处理完成: ${outputPath}`);
}
catch (error) {
console.error(`文本 ${i + 1} 处理失败:`, error);
}
}
}
/**
* 获取可用模型
*/
async function getModels() {
try {
const response = await client.getModels();
console.log('API响应状态:', response.code, response.message);
if (response.data) {
console.log('GPT模型数量:', response.data.gpt_models.length);
console.log('SoVITS模型数量:', response.data.sovits_models.length);
return {
gptModels: response.data.gpt_models,
sovitsModels: response.data.sovits_models
};
}
return { gptModels: [], sovitsModels: [] };
}
catch (error) {
console.error('获取模型失败:', error);
return { gptModels: [], sovitsModels: [] };
}
}
/**
* 创建模型配对
*/
async function createModelPairs() {
// 获取可用模型
const { gptModels, sovitsModels } = await getModels();
if (gptModels.length === 0 || sovitsModels.length === 0) {
console.error('没有足够的模型可用于配对');
return;
}
// 显示所有可能的模型配对
console.log('\n所有可能的模型配对:');
let pairIndex = 1;
for (const gptModel of gptModels) {
for (const sovitsModel of sovitsModels) {
console.log(`配对 ${pairIndex++}: GPT模型 "${gptModel.name}" + SoVITS模型 "${sovitsModel.name}"`);
}
}
// 选择第一个GPT模型和第一个SoVITS模型进行配对
const selectedGptModel = gptModels[0];
const selectedSovitsModel = sovitsModels[0];
console.log(`\n选择配对: GPT模型 "${selectedGptModel.name}" + SoVITS模型 "${selectedSovitsModel.name}"`);
return {
gptModel: selectedGptModel.path,
sovitsModel: selectedSovitsModel.path
};
}
/**
* 运行示例
*/
async function runExample() {
try {
// 获取模型配对
const modelPairs = await getModelPairs();
if (modelPairs.length === 0) {
console.log('没有找到配对的模型，示例结束');
return;
}
// 测试模型配对
await testModelPairs(modelPairs);
// 获取参考音频
const referenceAudiosResponse = await client.getReferenceAudios();
if (!referenceAudiosResponse.data || referenceAudiosResponse.data.audios.length === 0) {
console.log('没有找到参考音频，无法进行批量处理');
return;
}
// 选择第一个参考音频
const refAudio = referenceAudiosResponse.data.audios[0];
// 批量处理示例
const testTexts = [
'人工智能正在改变我们的生活方式。',
'语音合成技术让计算机能够说话。',
'深度学习模型可以生成逼真的人声。',
'未来，人机交互将变得更加自然。'
];
// 使用第一对模型进行批量处理
await batchProcess(modelPairs[0], testTexts, refAudio.path);
console.log('\n示例执行完成！');
}
catch (error) {
console.error('执行示例时出错:', error);
}
}
// 执行示例
runExample();