声音克隆 #

┌─────────────────────────────────────────────────────────────┐
│                     声音克隆流程                             │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  ┌──────────┐   ┌──────────┐   ┌──────────┐   ┌──────────┐ │
│  │ 参考音频  │ → │ 特征提取  │ → │ 声音编码  │ → │ 语音合成  │ │
│  └──────────┘   └──────────┘   └──────────┘   └──────────┘ │
│       │              │              │              │       │
│       ↓              ↓              ↓              ↓       │
│   6秒音频        说话人嵌入      风格特征      克隆语音     │
│                                                             │
└─────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────┐
│                     XTTS v2 特点                             │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  多语言支持：                                                │
│  ├── 支持 1100+ 语言                                        │
│  ├── 跨语言克隆（用英文音频合成中文）                        │
│  └── 自动语言检测                                           │
│                                                             │
│  声音克隆：                                                  │
│  ├── 只需 6 秒参考音频                                      │
│  ├── 高保真声音复制                                         │
│  ├── 保持说话人特征                                         │
│  └── 支持情感迁移                                           │
│                                                             │
│  模型规格：                                                  │
│  ├── 参数量：~1.8B                                          │
│  ├── 模型大小：~1.8 GB                                      │
│  ├── GPU 显存：4-8 GB                                       │
│  └── 推理时间：~2-3 秒/句                                   │
│                                                             │
└─────────────────────────────────────────────────────────────┘

from TTS.api import TTS
import torch

device = "cuda" if torch.cuda.is_available() else "cpu"
tts = TTS("tts_models/multilingual/multi-dataset/xtts_v2").to(device)

# 基础声音克隆
tts.tts_to_file(
    text="这是克隆的声音，听起来和原声音很像。",
    speaker_wav="reference.wav",
    language="zh-cn",
    file_path="cloned.wav"
)

# 基础命令
tts --text "This is cloned voice" \
    --model_name tts_models/multilingual/multi-dataset/xtts_v2 \
    --speaker_wav reference.wav \
    --language_idx en \
    --out_path cloned.wav

# 中文克隆
tts --text "这是克隆的中文语音" \
    --model_name tts_models/multilingual/multi-dataset/xtts_v2 \
    --speaker_wav reference.wav \
    --language_idx zh-cn \
    --out_path cloned_zh.wav

┌─────────────────────────────────────────────────────────────┐
│                   参考音频最佳实践                           │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  时长要求：                                                  │
│  ├── 最低：6 秒                                             │
│  ├── 推荐：10-30 秒                                         │
│  └── 最佳：30-60 秒                                         │
│                                                             │
│  音频质量：                                                  │
│  ├── 采样率：22050 Hz 或更高                                │
│  ├── 格式：WAV（无损）最佳                                  │
│  ├── 背景噪音：尽量低                                       │
│  └── 音量：适中，无削波                                     │
│                                                             │
│  内容要求：                                                  │
│  ├── 清晰朗读                                               │
│  ├── 自然语调                                               │
│  ├── 避免极端情感                                           │
│  └── 单一说话人                                             │
│                                                             │
└─────────────────────────────────────────────────────────────┘

import librosa
import soundfile as sf
import numpy as np

def preprocess_reference_audio(input_path, output_path, target_sr=22050):
    # 加载音频
    audio, sr = librosa.load(input_path, sr=None)
    
    # 重采样
    if sr != target_sr:
        audio = librosa.resample(audio, sr, target_sr)
    
    # 归一化
    audio = audio / np.max(np.abs(audio)) * 0.95
    
    # 去除静音
    audio, _ = librosa.effects.trim(audio, top_db=20)
    
    # 确保最小长度
    min_length = target_sr * 6  # 6秒
    if len(audio) < min_length:
        print(f"警告：音频长度不足 6 秒，当前 {len(audio)/target_sr:.1f} 秒")
    
    # 保存
    sf.write(output_path, audio, target_sr)
    print(f"预处理完成: {output_path}")
    return output_path

# 使用
preprocess_reference_audio("raw_audio.wav", "processed_reference.wav")

from TTS.api import TTS
import torch
import numpy as np
import soundfile as sf

device = "cuda" if torch.cuda.is_available() else "cpu"
tts = TTS("tts_models/multilingual/multi-dataset/xtts_v2").to(device)

# 使用多个参考音频
reference_files = ["voice1.wav", "voice2.wav", "voice3.wav"]

# 方式 1：拼接多个音频
def concatenate_references(files, output_path):
    audio_chunks = []
    for file in files:
        audio, sr = sf.read(file)
        audio_chunks.append(audio)
    
    combined = np.concatenate(audio_chunks)
    sf.write(output_path, combined, sr)
    return output_path

combined_ref = concatenate_references(reference_files, "combined_reference.wav")

tts.tts_to_file(
    text="Using multiple reference audios for better cloning.",
    speaker_wav=combined_ref,
    language="en",
    file_path="multi_ref.wav"
)

from TTS.api import TTS
import torch

device = "cuda" if torch.cuda.is_available() else "cpu"
tts = TTS("tts_models/multilingual/multi-dataset/xtts_v2").to(device)

# 使用英文参考音频合成中文
tts.tts_to_file(
    text="这是用英文声音克隆的中文语音。",
    speaker_wav="english_speaker.wav",
    language="zh-cn",
    file_path="cross_lang_zh.wav"
)

# 使用中文参考音频合成英文
tts.tts_to_file(
    text="This is English speech cloned from Chinese speaker.",
    speaker_wav="chinese_speaker.wav",
    language="en",
    file_path="cross_lang_en.wav"
)

from TTS.api import TTS
import torch

device = "cuda" if torch.cuda.is_available() else "cpu"
tts = TTS("tts_models/multilingual/multi-dataset/xtts_v2").to(device)

# 使用带情感的参考音频
emotional_refs = {
    "happy": "happy_voice.wav",
    "sad": "sad_voice.wav",
    "neutral": "neutral_voice.wav",
}

text = "Today is a wonderful day."

for emotion, ref_path in emotional_refs.items():
    tts.tts_to_file(
        text=text,
        speaker_wav=ref_path,
        language="en",
        file_path=f"emotion_{emotion}.wav"
    )
    print(f"生成: emotion_{emotion}.wav")

from TTS.api import TTS
import torch
import soundfile as sf
import numpy as np
from pathlib import Path

class VoiceCloner:
    def __init__(self, model_name="tts_models/multilingual/multi-dataset/xtts_v2"):
        self.device = "cuda" if torch.cuda.is_available() else "cpu"
        print(f"使用设备: {self.device}")
        self.tts = TTS(model_name).to(self.device)
        self.speaker_embeddings = {}
    
    def clone(self, text, reference_audio, language="en", output_path="output.wav"):
        self.tts.tts_to_file(
            text=text,
            speaker_wav=reference_audio,
            language=language,
            file_path=output_path
        )
        return output_path
    
    def batch_clone(self, texts, reference_audio, language="en", output_dir="output"):
        output_dir = Path(output_dir)
        output_dir.mkdir(exist_ok=True)
        
        results = []
        for i, text in enumerate(texts):
            output_path = output_dir / f"audio_{i:03d}.wav"
            self.clone(text, reference_audio, language, str(output_path))
            results.append(str(output_path))
        
        return results
    
    def save_speaker_embedding(self, name, reference_audio):
        self.speaker_embeddings[name] = reference_audio
        print(f"保存说话人嵌入: {name}")
    
    def load_speaker_embedding(self, name):
        return self.speaker_embeddings.get(name)
    
    def clone_with_saved_speaker(self, text, speaker_name, language="en", output_path="output.wav"):
        ref_audio = self.load_speaker_embedding(speaker_name)
        if ref_audio:
            return self.clone(text, ref_audio, language, output_path)
        else:
            raise ValueError(f"未找到说话人: {speaker_name}")

# 使用
cloner = VoiceCloner()

# 保存说话人
cloner.save_speaker_embedding("my_voice", "my_reference.wav")

# 使用保存的说话人
cloner.clone_with_saved_speaker(
    text="Hello, this is my cloned voice.",
    speaker_name="my_voice",
    language="en",
    output_path="cloned.wav"
)

import json
from pathlib import Path
import hashlib

class ReferenceAudioManager:
    def __init__(self, storage_dir="speaker_profiles"):
        self.storage_dir = Path(storage_dir)
        self.storage_dir.mkdir(exist_ok=True)
        self.index_file = self.storage_dir / "index.json"
        self.load_index()
    
    def load_index(self):
        if self.index_file.exists():
            with open(self.index_file, "r") as f:
                self.index = json.load(f)
        else:
            self.index = {}
    
    def save_index(self):
        with open(self.index_file, "w") as f:
            json.dump(self.index, f, indent=2)
    
    def add_speaker(self, name, audio_path, metadata=None):
        import shutil
        
        # 计算文件哈希
        with open(audio_path, "rb") as f:
            file_hash = hashlib.md5(f.read()).hexdigest()
        
        # 复制文件
        dest_path = self.storage_dir / f"{name}_{file_hash}.wav"
        shutil.copy(audio_path, dest_path)
        
        # 更新索引
        self.index[name] = {
            "path": str(dest_path),
            "hash": file_hash,
            "metadata": metadata or {}
        }
        self.save_index()
        
        print(f"添加说话人: {name}")
        return str(dest_path)
    
    def get_speaker(self, name):
        if name in self.index:
            return self.index[name]["path"]
        return None
    
    def list_speakers(self):
        return list(self.index.keys())
    
    def remove_speaker(self, name):
        if name in self.index:
            import os
            os.remove(self.index[name]["path"])
            del self.index[name]
            self.save_index()
            print(f"删除说话人: {name}")

# 使用
manager = ReferenceAudioManager()

# 添加说话人
manager.add_speaker(
    name="john",
    audio_path="john_voice.wav",
    metadata={"language": "en", "gender": "male"}
)

# 获取说话人
john_audio = manager.get_speaker("john")

# 列出所有说话人
print(manager.list_speakers())

┌─────────────────────────────────────────────────────────────┐
│                   参考音频选择指南                           │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  最佳选择：                                                  │
│  ├── 专业录音棚录制                                         │
│  ├── 清晰、无噪音                                           │
│  ├── 自然、不刻意的朗读                                     │
│  └── 10-30 秒的连续语音                                     │
│                                                             │
│  避免：                                                      │
│  ├── 背景音乐或噪音                                         │
│  ├── 多人说话                                               │
│  ├── 极端情感表达                                           │
│  ├── 过于快速或缓慢                                         │
│  └── 低质量录音                                             │
│                                                             │
│  提升技巧：                                                  │
│  ├── 使用降噪工具预处理                                     │
│  ├── 选择多种内容的参考音频                                 │
│  ├── 确保音量一致                                           │
│  └── 避免口吃或停顿                                         │
│                                                             │
└─────────────────────────────────────────────────────────────┘

import numpy as np
import soundfile as sf
import librosa

def evaluate_reference_quality(audio_path):
    audio, sr = sf.read(audio_path)
    
    metrics = {}
    
    # 时长
    duration = len(audio) / sr
    metrics["duration"] = duration
    metrics["duration_ok"] = duration >= 6
    
    # 音量
    rms = np.sqrt(np.mean(audio ** 2))
    db = 20 * np.log10(rms)
    metrics["volume_db"] = db
    metrics["volume_ok"] = -30 < db < -10
    
    # 峰值
    peak = np.max(np.abs(audio))
    metrics["peak"] = peak
    metrics["no_clipping"] = peak < 0.99
    
    # 信噪比估计（简化）
    noise_floor = np.percentile(np.abs(audio), 5)
    signal_level = np.percentile(np.abs(audio), 95)
    snr_estimate = 20 * np.log10(signal_level / (noise_floor + 1e-10))
    metrics["snr_estimate"] = snr_estimate
    metrics["snr_ok"] = snr_estimate > 20
    
    # 综合评分
    score = sum([
        metrics["duration_ok"],
        metrics["volume_ok"],
        metrics["no_clipping"],
        metrics["snr_ok"]
    ])
    metrics["overall_score"] = score / 4 * 100
    
    return metrics

# 使用
metrics = evaluate_reference_quality("reference.wav")
print(f"质量评分: {metrics['overall_score']:.0f}%")
print(f"时长: {metrics['duration']:.1f}s {'✓' if metrics['duration_ok'] else '✗'}")
print(f"音量: {metrics['volume_db']:.1f}dB {'✓' if metrics['volume_ok'] else '✗'}")
print(f"无削波: {'✓' if metrics['no_clipping'] else '✗'}")
print(f"信噪比: {metrics['snr_estimate']:.1f}dB {'✓' if metrics['snr_ok'] else '✗'}")

# 解决方案：使用更长的参考音频
# 或使用多个参考音频拼接

def improve_cloning(reference_files):
    import numpy as np
    import soundfile as sf
    
    # 选择最佳质量的音频
    best_audio = None
    best_score = 0
    
    for file in reference_files:
        metrics = evaluate_reference_quality(file)
        if metrics["overall_score"] > best_score:
            best_score = metrics["overall_score"]
            best_audio = file
    
    return best_audio

# 解决方案：使用目标语言的参考音频
# 或使用更长的参考音频

def cross_language_clone(tts, text, ref_audio, target_lang, ref_lang=None):
    # 如果参考音频语言与目标语言不同
    # 建议使用更长的参考音频（30秒以上）
    
    tts.tts_to_file(
        text=text,
        speaker_wav=ref_audio,
        language=target_lang,
        file_path="output.wav"
    )

import torch
from TTS.api import TTS

# 解决方案 1：使用 CPU
tts = TTS("tts_models/multilingual/multi-dataset/xtts_v2").to("cpu")

# 解决方案 2：清理缓存
torch.cuda.empty_cache()

# 解决方案 3：使用半精度
tts = TTS("tts_models/multilingual/multi-dataset/xtts_v2")
tts.model = tts.model.half()