neverlib 0.2.7__py3-none-any.whl → 0.2.9__py3-none-any.whl

neverlib/.history/metrics/snr_20250827234028.py

@@ -1,186 +0,0 @@
-import librosa
-import numpy as np
-from neverlib.vad.utils import vad2nad
-from neverlib.filter import HPFilter
-
-
-def get_snr(speech, noise, hpf=False, sr=16000, order=6, cutoff=100):
-    """计算信噪比
-    Args:
-        speech: 语音音频
-        noise: 噪声音频
-    Returns:
-        snr: 信噪比
-    """
-    assert speech.ndim == noise.ndim, "speech和noise的维度不一样"
-    if hpf:
-        speech = HPFilter(speech, sr=sr, order=order, cutoff=cutoff)
-        noise = HPFilter(noise, sr=sr, order=order, cutoff=cutoff)
-
-    power_speech = np.mean(speech**2)
-    power_noise = max(np.mean(noise**2), 1e-10)
-
-    snr = 10 * np.log10(power_speech / power_noise)
-    return snr
-
-
-def get_snr_from_noisy(noisy, speech_vad=None):
-    """根据带噪音频计算信噪比
-    Args:
-        noisy: 带噪音频
-        speech_vad: [{start:xxx, end:xxx}, ...]
-    Returns:
-        snr: 信噪比
-    """
-    assert speech_vad is not None, "speech_vad不能为空"
-
-    # 提取语音段
-    speech_segments = []
-    for segment in speech_vad:
-        start = segment['start']
-        end = segment['end']
-        speech_segments.append(noisy[start:end])
-    speech = np.concatenate(speech_segments, axis=0)
-
-    # 提取非语音段
-    noise_segments = []
-    noise_point_list = vad2nad(speech_vad, len(noisy))
-    for noise_point in noise_point_list:
-        noise_segments.append(noisy[noise_point['start']:noise_point['end']])
-    noise = np.concatenate(noise_segments, axis=0)
-
-    P_speech_noise = np.mean(speech ** 2)  # 语音+噪声功率
-    P_noise = max(np.mean(noise ** 2), EPS)  # 纯噪声功率
-
-    # 计算净语音功率
-    P_speech = max(P_speech_noise - P_noise, EPS)
-    snr = 10 * np.log10(P_speech / P_noise)
-
-    return snr
-
-
-def seg_snr(clean, noisy, frame_length: int, hop_length: int):
-    """
-    分帧计算信噪比
-    Args:
-        clean: 干净音频, numpy array
-        noisy: 带噪音频, numpy array
-        frame_length: 帧长
-        hop_length: 帧移
-    Returns:
-        snr_mean: 平均信噪比, float
-    Raises:
-        ValueError: 当输入参数不合法时抛出
-    """
-    assert clean.shape == noisy.shape, "clean和noisy的维度不一样"
-
-    # 分帧
-    clean_frames = librosa.util.frame(clean, frame_length=frame_length, hop_length=hop_length)  # (frame_length, n_frames)
-    noisy_frames = librosa.util.frame(noisy, frame_length=frame_length, hop_length=hop_length)  # (frame_length, n_frames)
-
-    # 计算每帧的信噪比
-    snr_frames = []
-    for i in range(clean_frames.shape[1]):
-        clean_frame = clean_frames[:, i]
-        noisy_frame = noisy_frames[:, i]
-        # 跳过静音帧
-        if np.all(np.abs(clean_frame) < 1e-6) or np.all(np.abs(noisy_frame) < 1e-6):
-            continue
-        snr_frames.append(get_snr(clean_frame, noisy_frame))
-
-    # 如果所有帧都是静音
-    if not snr_frames:
-        return float('-inf')
-
-    return np.mean(snr_frames)
-
-
-def psnr(clean, noisy, max_val=None):
-    """
-    计算峰值信噪比
-    Args:
-        clean: 干净音频, numpy array
-        noisy: 带噪音频, numpy array
-        max_val: 信号最大值, 如果为None则使用clean信号的实际最大值
-    Returns:
-        psnr: 峰值信噪比, 单位dB
-    """
-    assert clean.shape == noisy.shape, "clean和noisy的维度不一样"
-
-    # 如果没有指定最大值, 使用clean信号的实际最大值
-    if max_val is None:
-        max_val = np.abs(clean).max()
-
-    # 计算均方误差 (MSE)
-    mse = np.mean((clean - noisy) ** 2)
-
-    # 避免除以0
-    if mse == 0:
-        return float('inf')
-
-    # 计算PSNR
-    psnr = 10 * np.log10(max_val**2 / mse)
-    return psnr
-
-
-def si_sdr(reference, estimate, epsilon=1e-8):
-    """
-    计算尺度不变信噪比 (Scale-Invariant Signal-to-Distortion Ratio, SI-SDR)。
-
-    Args:
-        reference (np.ndarray): 原始的、干净的参考信号 (一维数组)。
-        estimate (np.ndarray): 模型估计或处理后的信号 (一维数组)。
-        epsilon (float): 一个非常小的数值, 用于防止分母为零, 保证数值稳定性。
-
-    Returns:
-        float: SI-SDR 值, 单位为分贝 (dB)。
-    """
-    assert reference.shape == estimate.shape, "reference和estimate的维度不一样"
-
-    # 2. 零均值化 (可选但推荐)
-    # 移除直流分量, 使计算更关注信号的动态变化
-    reference = reference - np.mean(reference)
-    estimate = estimate - np.mean(estimate)
-
-    # 3. 计算目标信号分量 (s_target)
-    # s_target 是 estimate 在 reference 上的投影
-    # 公式: s_target = (<ŝ, s> / ||s||²) * s
-    dot_product = np.dot(estimate, reference)   # <ŝ, s> (点积)
-    norm_s_squared = np.dot(reference, reference)   # ||s||² (s的能量)
-
-    # 检查参考信号能量, 避免除以零
-    if norm_s_squared < epsilon:
-        # 如果参考信号几乎是静音, SI-SDR没有意义
-        return -np.inf  # 返回负无穷或np.nan
-
-    alpha = dot_product / (norm_s_squared + epsilon)    # 最佳缩放因子 α
-    s_target = alpha * reference
-
-    # 4. 计算误差/失真分量 (e_noise)
-    e_noise = estimate - s_target
-
-    # 5. 计算 SI-SDR
-    # SI-SDR = 10 * log10 ( ||s_target||² / ||e_noise||² )
-    power_s_target = np.sum(s_target**2)    # ||s_target||²
-    power_e_noise = np.sum(e_noise**2)      # ||e_noise||²
-
-    # 同样加上 epsilon 防止除以零
-    if power_e_noise < epsilon:
-        # 如果噪声能量极小, 说明匹配得非常好
-        return np.inf  # 返回正无穷
-
-    si_sdr_val = 10 * np.log10(power_s_target / (power_e_noise + epsilon))
-
-    return si_sdr_val
-
-
-if __name__ == "__main__":
-    # 生成测试信号
-    speech = np.random.randn(1000)
-    noise = np.random.randn(1000) * 0.1  # 较小的噪声
-    noisy = speech + noise
-
-    # 测试各种信噪比计算方法
-    print(f"SNR: {get_snr(speech, noise):.2f} dB")
-    print(f"Segmental SNR: {seg_snr(speech, noisy, 100, 50):.2f} dB")
-    print(f"PSNR: {psnr(speech, noisy):.2f} dB")

neverlib/.history/metrics/snr_20250827234030.py

@@ -1,186 +0,0 @@
-import librosa
-import numpy as np
-from neverlib.vad.utils import vad2nad
-from neverlib.filter import HPFilter
-
-
-def get_snr(speech, noise, hpf=False, sr=16000, order=6, cutoff=100):
-    """计算信噪比
-    Args:
-        speech: 语音音频
-        noise: 噪声音频
-    Returns:
-        snr: 信噪比
-    """
-    assert speech.ndim == noise.ndim, "speech和noise的维度不一样"
-    if hpf:
-        speech = HPFilter(speech, sr=sr, order=order, cutoff=cutoff)
-        noise = HPFilter(noise, sr=sr, order=order, cutoff=cutoff)
-
-    power_speech = np.mean(speech**2)
-    power_noise = max(np.mean(noise**2), 1e-10)
-
-    snr = 10 * np.log10(power_speech / power_noise)
-    return snr
-
-
-def get_snr_from_noisy(noisy, speech_vad=None):
-    """根据带噪音频计算信噪比
-    Args:
-        noisy: 带噪音频
-        speech_vad: [{start:xxx, end:xxx}, ...]
-    Returns:
-        snr: 信噪比
-    """
-    assert speech_vad is not None, "speech_vad不能为空"
-
-    # 提取语音段
-    speech_segments = []
-    for segment in speech_vad:
-        start = segment['start']
-        end = segment['end']
-        speech_segments.append(noisy[start:end])
-    speech = np.concatenate(speech_segments, axis=0)
-
-    # 提取非语音段
-    noise_segments = []
-    noise_point_list = vad2nad(speech_vad, len(noisy))
-    for noise_point in noise_point_list:
-        noise_segments.append(noisy[noise_point['start']:noise_point['end']])
-    noise = np.concatenate(noise_segments, axis=0)
-
-    P_speech_noise = np.mean(speech ** 2)  # 语音+噪声功率
-    P_noise = max(np.mean(noise ** 2), EPS)  # 纯噪声功率
-
-    # 计算净语音功率
-    P_speech = max(P_speech_noise - P_noise, EPS)
-    snr = 10 * np.log10(P_speech / P_noise)
-
-    return snr
-
-
-def seg_snr(clean, noisy, frame_length: int, hop_length: int):
-    """
-    分帧计算信噪比
-    Args:
-        clean: 干净音频, numpy array
-        noisy: 带噪音频, numpy array
-        frame_length: 帧长
-        hop_length: 帧移
-    Returns:
-        snr_mean: 平均信噪比, float
-    Raises:
-        ValueError: 当输入参数不合法时抛出
-    """
-    assert clean.shape == noisy.shape, "clean和noisy的维度不一样"
-
-    # 分帧
-    clean_frames = librosa.util.frame(clean, frame_length=frame_length, hop_length=hop_length)  # (frame_length, n_frames)
-    noisy_frames = librosa.util.frame(noisy, frame_length=frame_length, hop_length=hop_length)  # (frame_length, n_frames)
-
-    # 计算每帧的信噪比
-    snr_frames = []
-    for i in range(clean_frames.shape[1]):
-        clean_frame = clean_frames[:, i]
-        noisy_frame = noisy_frames[:, i]
-        # 跳过静音帧
-        if np.all(np.abs(clean_frame) < 1e-6) or np.all(np.abs(noisy_frame) < 1e-6):
-            continue
-        snr_frames.append(get_snr(clean_frame, noisy_frame))
-
-    # 如果所有帧都是静音
-    if not snr_frames:
-        return float('-inf')
-
-    return np.mean(snr_frames)
-
-
-def psnr(clean, noisy, max_val=None):
-    """
-    计算峰值信噪比
-    Args:
-        clean: 干净音频, numpy array
-        noisy: 带噪音频, numpy array
-        max_val: 信号最大值, 如果为None则使用clean信号的实际最大值
-    Returns:
-        psnr: 峰值信噪比, 单位dB
-    """
-    assert clean.shape == noisy.shape, "clean和noisy的维度不一样"
-
-    # 如果没有指定最大值, 使用clean信号的实际最大值
-    if max_val is None:
-        max_val = np.abs(clean).max()
-
-    # 计算均方误差 (MSE)
-    mse = np.mean((clean - noisy) ** 2)
-
-    # 避免除以0
-    if mse == 0:
-        return float('inf')
-
-    # 计算PSNR
-    psnr = 10 * np.log10(max_val**2 / mse)
-    return psnr
-
-
-def si_sdr(reference, estimate, epsilon=1e-8):
-    """
-    计算尺度不变信噪比 (Scale-Invariant Signal-to-Distortion Ratio, SI-SDR)。
-
-    Args:
-        reference (np.ndarray): 原始的、干净的参考信号 (一维数组)。
-        estimate (np.ndarray): 模型估计或处理后的信号 (一维数组)。
-        epsilon (float): 一个非常小的数值, 用于防止分母为零, 保证数值稳定性。
-
-    Returns:
-        float: SI-SDR 值, 单位为分贝 (dB)。
-    """
-    assert reference.shape == estimate.shape, "reference和estimate的维度不一样"
-
-    # 2. 零均值化 (可选但推荐)
-    # 移除直流分量, 使计算更关注信号的动态变化
-    reference = reference - np.mean(reference)
-    estimate = estimate - np.mean(estimate)
-
-    # 3. 计算目标信号分量 (s_target)
-    # s_target 是 estimate 在 reference 上的投影
-    # 公式: s_target = (<ŝ, s> / ||s||²) * s
-    dot_product = np.dot(estimate, reference)   # <ŝ, s> (点积)
-    norm_s_squared = np.dot(reference, reference)   # ||s||² (s的能量)
-
-    # 检查参考信号能量, 避免除以零
-    if norm_s_squared < epsilon:
-        # 如果参考信号几乎是静音, SI-SDR没有意义
-        return -np.inf  # 返回负无穷或np.nan
-
-    alpha = dot_product / (norm_s_squared + epsilon)    # 最佳缩放因子 α
-    s_target = alpha * reference
-
-    # 4. 计算误差/失真分量 (e_noise)
-    e_noise = estimate - s_target
-
-    # 5. 计算 SI-SDR
-    # SI-SDR = 10 * log10 ( ||s_target||² / ||e_noise||² )
-    power_s_target = np.sum(s_target**2)    # ||s_target||²
-    power_e_noise = np.sum(e_noise**2)      # ||e_noise||²
-
-    # 同样加上 epsilon 防止除以零
-    if power_e_noise < epsilon:
-        # 如果噪声能量极小, 说明匹配得非常好
-        return np.inf  # 返回正无穷
-
-    si_sdr_val = 10 * np.log10(power_s_target / (power_e_noise + epsilon))
-
-    return si_sdr_val
-
-
-if __name__ == "__main__":
-    # 生成测试信号
-    speech = np.random.randn(1000)
-    noise = np.random.randn(1000) * 0.1  # 较小的噪声
-    noisy = speech + noise
-
-    # 测试各种信噪比计算方法
-    print(f"SNR: {get_snr(speech, noise):.2f} dB")
-    print(f"Segmental SNR: {seg_snr(speech, noisy, 100, 50):.2f} dB")
-    print(f"PSNR: {psnr(speech, noisy):.2f} dB")

neverlib/.history/metrics/spec_20250805234209.py

@@ -1,45 +0,0 @@
-"""
-频域的客观评价指标
-LSD: 对数谱距离
-"""
-import sys
-sys.path.append("..")
-import numpy as np
-import librosa
-from utils import EPS
-
-
-def lsd(reference, estimate, n_fft=2048, hop_length=512, win_length=None):
-    """
-    计算两个一维音频信号之间的对数谱距离 (Log-Spectral Distance, LSD)。
-    该实现遵循标准的LSD定义: 整体均方根误差。
-
-    Args:
-        reference (np.ndarray): 原始的、干净的参考信号 (一维数组)。
-        estimate (np.ndarray): 模型估计或处理后的信号 (一维数组)。
-        n_fft (int): FFT点数, 决定了频率分辨率。
-        hop_length (int): 帧移, 决定了时间分辨率。
-        win_length (int, optional): 窗长。如果为None, 则默认为n_fft。
-        epsilon (float): 一个非常小的数值, 用于防止对零取对数, 保证数值稳定性。
-
-    Returns:
-        float: 对数谱距离值, 单位为分贝 (dB)。
-    """
-    assert reference.ndim == 1 and estimate.ndim == 1, "输入信号必须是一维数组。"
-    
-    if win_length is None:
-        win_length = n_fft
-
-    reference_stft = librosa.stft(reference, n_fft=n_fft, hop_length=hop_length, win_length=win_length) # (F,T)
-    estimate_stft = librosa.stft(estimate, n_fft=n_fft, hop_length=hop_length, win_length=win_length) # (F,T)
-
-    reference_power_spec = np.abs(reference_stft) ** 2 # (F,T)
-    estimate_power_spec = np.abs(estimate_stft) ** 2 # (F,T)
-
-    reference_log_power_spec = 10 * np.log10(reference_power_spec + EPS)
-    estimate_log_power_spec = 10 * np.log10(estimate_power_spec + EPS)
-
-    squared_error = (reference_log_power_spec - estimate_log_power_spec) ** 2
-    lsd_val = np.sqrt(np.mean(squared_error))
-
-    return lsd_val

neverlib/.history/metrics/spec_20250816135530.py

@@ -1,11 +0,0 @@
-"""
-频域的客观评价指标
-LSD: 对数谱距离
-"""
-import sys
-sys.path.append("..")
-import numpy as np
-import librosa
-from utils import EPS
-
-

neverlib/.history/metrics/spec_20250816135654.py

@@ -1,16 +0,0 @@
-'''
-Author: 凌逆战 | Never
-Date: 2025-08-05 23:42:10
-Description: 
-'''
-"""
-频域的客观评价指标
-LSD: 对数谱距离
-"""
-import sys
-sys.path.append("..")
-import numpy as np
-import librosa
-from utils import EPS
-
-

neverlib/.history/metrics/spec_20250816135736.py

@@ -1,68 +0,0 @@
-'''
-Author: 凌逆战 | Never
-Date: 2025-08-16 13:51:57
-Description: 频域客观度量指标
-'''
-
-import librosa
-import numpy as np
-import soundfile as sf
-from neverlib.utils import EPS
-
-
-
-
-
-def lsd(ref_wav, test_wav, n_fft=2048, hop_length=512, win_length=None):
-    """
-    计算两个一维音频信号之间的对数谱距离 (Log-Spectral Distance, LSD)。
-    该实现遵循标准的LSD定义: 整体均方根误差。
-
-    Args:
-        ref_wav (np.ndarray): 原始的、干净的参考信号 (一维数组)。
-        test_wav (np.ndarray): 模型估计或处理后的信号 (一维数组)。
-        n_fft (int): FFT点数, 决定了频率分辨率。
-        hop_length (int): 帧移, 决定了时间分辨率。
-        win_length (int, optional): 窗长。如果为None, 则默认为n_fft。
-        epsilon (float): 一个非常小的数值, 用于防止对零取对数, 保证数值稳定性。
-
-    Returns:
-        float: 对数谱距离值, 单位为分贝 (dB)。
-    """
-    assert ref_wav.ndim == 1 and test_wav.ndim == 1, "输入信号必须是一维数组。"
-    
-    if win_length is None:
-        win_length = n_fft
-
-    ref_stft = librosa.stft(ref_wav, n_fft=n_fft, hop_length=hop_length, win_length=win_length) # (F,T)
-    test_stft = librosa.stft(test_wav, n_fft=n_fft, hop_length=hop_length, win_length=win_length) # (F,T)
-
-    ref_power_spec = np.abs(ref_stft) ** 2 # (F,T)
-    test_power_spec = np.abs(test_stft) ** 2 # (F,T)
-
-    ref_log_power_spec = 10 * np.log10(ref_power_spec + EPS)
-    test_log_power_spec = 10 * np.log10(test_power_spec + EPS)
-
-    squared_error = (ref_log_power_spec - test_log_power_spec) ** 2
-    lsd_val = np.sqrt(np.mean(squared_error))
-
-    return lsd_val
-
-def mcd(ref_wav, test_wav, sr=16000):
-    """
-    梅尔倒谱距离 Mel-Cepstral Distance
-    ref_spec: 参考频谱
-    test_spec: 测试频谱
-    """
-    ref_wav, ref_sr = sf.read(ref_wav)
-    test_wav, test_sr = sf.read(test_wav)
-    assert ref_sr == test_sr == sr, "采样率必须为16000Hz"
-    assert len(ref_wav) == len(test_wav), "音频长度必须相同"
-    
-    ref_mfcc = librosa.feature.mfcc(y=ref_wav, sr=sr)
-    test_mfcc = librosa.feature.mfcc(y=test_wav, sr=sr)
-    
-    # 计算 MCD (跳过 0 阶)
-    diff = ref_mfcc[1:] - test_mfcc[1:]
-    mcd = (10.0 / np.log(10)) * np.sqrt(2 * np.mean(np.sum(diff ** 2, axis=0)))
-    return mcd

neverlib/.history/metrics/spec_20250816135904.py

@@ -1,75 +0,0 @@
-'''
-Author: 凌逆战 | Never
-Date: 2025-08-16 13:51:57
-Description: 频域客观度量指标
-'''
-
-import librosa
-import numpy as np
-import soundfile as sf
-from neverlib.utils import EPS
-
-
-def sd(ref_wav, test_wav, n_fft=2048, hop_length=512, win_length=None):
-    """
-    频谱距离
-    """
-    ref_spec = librosa.stft(ref_wav, n_fft=n_fft, hop_length=hop_length, win_length=win_length)
-    test_spec = librosa.stft(test_wav, n_fft=n_fft, hop_length=hop_length, win_length=win_length)
-    return np.sqrt(np.mean((ref_spec - test_spec) ** 2))
-
-
-
-def lsd(ref_wav, test_wav, n_fft=2048, hop_length=512, win_length=None):
-    """
-    计算两个一维音频信号之间的对数谱距离 (Log-Spectral Distance, LSD)。
-    该实现遵循标准的LSD定义: 整体均方根误差。
-
-    Args:
-        ref_wav (np.ndarray): 原始的、干净的参考信号 (一维数组)。
-        test_wav (np.ndarray): 模型估计或处理后的信号 (一维数组)。
-        n_fft (int): FFT点数, 决定了频率分辨率。
-        hop_length (int): 帧移, 决定了时间分辨率。
-        win_length (int, optional): 窗长。如果为None, 则默认为n_fft。
-        epsilon (float): 一个非常小的数值, 用于防止对零取对数, 保证数值稳定性。
-
-    Returns:
-        float: 对数谱距离值, 单位为分贝 (dB)。
-    """
-    assert ref_wav.ndim == 1 and test_wav.ndim == 1, "输入信号必须是一维数组。"
-    
-    if win_length is None:
-        win_length = n_fft
-
-    ref_stft = librosa.stft(ref_wav, n_fft=n_fft, hop_length=hop_length, win_length=win_length) # (F,T)
-    test_stft = librosa.stft(test_wav, n_fft=n_fft, hop_length=hop_length, win_length=win_length) # (F,T)
-
-    ref_power_spec = np.abs(ref_stft) ** 2 # (F,T)
-    test_power_spec = np.abs(test_stft) ** 2 # (F,T)
-
-    ref_log_power_spec = 10 * np.log10(ref_power_spec + EPS)
-    test_log_power_spec = 10 * np.log10(test_power_spec + EPS)
-
-    squared_error = (ref_log_power_spec - test_log_power_spec) ** 2
-    lsd_val = np.sqrt(np.mean(squared_error))
-
-    return lsd_val
-
-def mcd(ref_wav, test_wav, sr=16000):
-    """
-    梅尔倒谱距离 Mel-Cepstral Distance
-    ref_spec: 参考频谱
-    test_spec: 测试频谱
-    """
-    ref_wav, ref_sr = sf.read(ref_wav)
-    test_wav, test_sr = sf.read(test_wav)
-    assert ref_sr == test_sr == sr, "采样率必须为16000Hz"
-    assert len(ref_wav) == len(test_wav), "音频长度必须相同"
-    
-    ref_mfcc = librosa.feature.mfcc(y=ref_wav, sr=sr)
-    test_mfcc = librosa.feature.mfcc(y=test_wav, sr=sr)
-    
-    # 计算 MCD (跳过 0 阶)
-    diff = ref_mfcc[1:] - test_mfcc[1:]
-    mcd = (10.0 / np.log(10)) * np.sqrt(2 * np.mean(np.sum(diff ** 2, axis=0)))
-    return mcd

neverlib/.history/metrics/spec_20250816135921.py

@@ -1,82 +0,0 @@
-'''
-Author: 凌逆战 | Never
-Date: 2025-08-16 13:51:57
-Description: 频域客观度量指标
-'''
-
-import librosa
-import numpy as np
-import soundfile as sf
-from neverlib.utils import EPS
-
-
-def sd(ref_wav, test_wav, n_fft=2048, hop_length=512, win_length=None):
-    """
-    频谱距离
-    """
-    ref_spec = librosa.stft(ref_wav, n_fft=n_fft, hop_length=hop_length, win_length=win_length)
-    test_spec = librosa.stft(test_wav, n_fft=n_fft, hop_length=hop_length, win_length=win_length)
-    return np.sqrt(np.mean((ref_spec - test_spec) ** 2))
-
-
-
-def lsd(ref_wav, test_wav, n_fft=2048, hop_length=512, win_length=None):
-    """
-    计算两个一维音频信号之间的对数谱距离 (Log-Spectral Distance, LSD)。
-    该实现遵循标准的LSD定义: 整体均方根误差。
-
-    Args:
-        ref_wav (np.ndarray): 原始的、干净的参考信号 (一维数组)。
-        test_wav (np.ndarray): 模型估计或处理后的信号 (一维数组)。
-        n_fft (int): FFT点数, 决定了频率分辨率。
-        hop_length (int): 帧移, 决定了时间分辨率。
-        win_length (int, optional): 窗长。如果为None, 则默认为n_fft。
-        epsilon (float): 一个非常小的数值, 用于防止对零取对数, 保证数值稳定性。
-
-    Returns:
-        float: 对数谱距离值, 单位为分贝 (dB)。
-    """
-    assert ref_wav.ndim == 1 and test_wav.ndim == 1, "输入信号必须是一维数组。"
-    
-    if win_length is None:
-        win_length = n_fft
-
-    ref_stft = librosa.stft(ref_wav, n_fft=n_fft, hop_length=hop_length, win_length=win_length) # (F,T)
-    test_stft = librosa.stft(test_wav, n_fft=n_fft, hop_length=hop_length, win_length=win_length) # (F,T)
-
-    ref_power_spec = np.abs(ref_stft) ** 2 # (F,T)
-    test_power_spec = np.abs(test_stft) ** 2 # (F,T)
-
-    ref_log_power_spec = 10 * np.log10(ref_power_spec + EPS)
-    test_log_power_spec = 10 * np.log10(test_power_spec + EPS)
-
-    squared_error = (ref_log_power_spec - test_log_power_spec) ** 2
-    lsd_val = np.sqrt(np.mean(squared_error))
-
-    return lsd_val
-
-def mcd(ref_wav, test_wav, sr=16000):
-    """
-    梅尔倒谱距离 Mel-Cepstral Distance
-    ref_spec: 参考频谱
-    test_spec: 测试频谱
-    """
-    ref_wav, ref_sr = sf.read(ref_wav)
-    test_wav, test_sr = sf.read(test_wav)
-    assert ref_sr == test_sr == sr, "采样率必须为16000Hz"
-    assert len(ref_wav) == len(test_wav), "音频长度必须相同"
-    
-    ref_mfcc = librosa.feature.mfcc(y=ref_wav, sr=sr)
-    test_mfcc = librosa.feature.mfcc(y=test_wav, sr=sr)
-    
-    # 计算 MCD (跳过 0 阶)
-    diff = ref_mfcc[1:] - test_mfcc[1:]
-    mcd = (10.0 / np.log(10)) * np.sqrt(2 * np.mean(np.sum(diff ** 2, axis=0)))
-    return mcd
-
-if __name__ == "__main__":
-    ref_file = "../data/vad_example.wav"   # 参考语音文件路径
-    test_file = "../data/vad_example.wav" # 测试语音文件路径
-
-    avg_dist, dist_list = lpc_lsp_distance(ref_file, test_file)
-    print(f"平均 LSP MSE 失真: {avg_dist}")