neverlib 0.2.3__py3-none-any.whl → 0.2.4__py3-none-any.whl

neverlib/.history/metrics/dnsmos_20250815184200.py

@@ -0,0 +1,117 @@
+'''
+Author: 凌逆战 | Never
+Date: 2025-08-06 10:00:00
+Description: 
+要计算个性化 MOS 分数（干扰说话者受到惩罚），请提供“-p”参数，例如：python dnsmos.py -t ./SampleClips -o sample.csv -p
+要计算常规 MOS 分数，请省略“-p”参数。例如：python dnsmos.py -t ./SampleClips -o sample.csv
+'''
+import argparse
+import concurrent.futures
+import glob
+import os
+import librosa
+import numpy as np
+import onnxruntime as ort
+import pandas as pd
+import soundfile as sf
+from tqdm import tqdm
+from neverlib.utils import get_path_list
+
+
+class ComputeScore:
+    def __init__(self, is_personalized_MOS, sr, input_length) -> None:
+        self.sr = sr
+        self.input_length = input_length
+        self.is_personalized_MOS = is_personalized_MOS
+        p808_model_path = "./DNSMOS/model_v8.onnx"
+        if is_personalized_MOS:
+            primary_model_path = "./pDNSMOS/sig_bak_ovr.onnx"
+        else:
+            primary_model_path = "./DNSMOS/sig_bak_ovr.onnx"
+
+        self.onnx_sess = ort.InferenceSession(primary_model_path)
+        self.p808_onnx_sess = ort.InferenceSession(p808_model_path)
+
+    def audio_melspec(self, audio, n_mels=120, frame_size=320, hop_length=160, to_db=True):
+        mel_spec = librosa.feature.melspectrogram(y=audio, sr=self.sr, n_fft=frame_size + 1, hop_length=hop_length, n_mels=n_mels)
+        if to_db:
+            mel_spec = (librosa.power_to_db(mel_spec, ref=np.max) + 40) / 40
+        return mel_spec.T
+
+    def get_polyfit_val(self, sig, bak, ovr):
+        if self.is_personalized_MOS:
+            p_ovr = np.poly1d([-0.00533021, 0.005101, 1.18058466, -0.11236046])
+            p_sig = np.poly1d([-0.01019296, 0.02751166, 1.19576786, -0.24348726])
+            p_bak = np.poly1d([-0.04976499, 0.44276479, -0.1644611, 0.96883132])
+        else:
+            p_ovr = np.poly1d([-0.06766283, 1.11546468, 0.04602535])
+            p_sig = np.poly1d([-0.08397278, 1.22083953, 0.0052439])
+            p_bak = np.poly1d([-0.13166888, 1.60915514, -0.39604546])
+
+        sig_poly, bak_poly, ovr_poly = p_sig(sig), p_bak(bak), p_ovr(ovr)
+
+        return sig_poly, bak_poly, ovr_poly
+
+    def __call__(self, wav_path):
+        wav, wav_sr = sf.read(wav_path, dtype='float32')
+        if wav_sr != self.sr:
+            wav = librosa.resample(wav, wav_sr, self.sr)
+        else:
+            wav = wav
+        len_samples = int(self.input_length * self.sr)
+        while len(wav) < len_samples:
+            wav = np.append(wav, wav)
+
+        num_hops = int(np.floor(len(wav) / self.sr) - self.input_length) + 1
+        hop_len_samples = self.sr
+        predicted_mos_sig_seg_raw = []
+        predicted_mos_bak_seg_raw = []
+        predicted_mos_ovr_seg_raw = []
+        predicted_mos_sig_seg = []
+        predicted_mos_bak_seg = []
+        predicted_mos_ovr_seg = []
+        predicted_p808_mos = []
+
+        for idx in range(num_hops):
+            wav_seg = wav[int(idx * hop_len_samples): int((idx + self.input_length) * hop_len_samples)]
+            if len(wav_seg) < len_samples:
+                continue
+
+            input_features = np.array(wav_seg)[np.newaxis, :]
+            p808_input_features = np.array(self.audio_melspec(audio=wav_seg[:-160]))[np.newaxis, :, :]
+            oi = {'input_1': input_features}
+            p808_oi = {'input_1': p808_input_features}
+            p808_mos = self.p808_onnx_sess.run(None, p808_oi)[0][0][0]
+            mos_sig_raw, mos_bak_raw, mos_ovr_raw = self.onnx_sess.run(None, oi)[0][0]
+            mos_sig, mos_bak, mos_ovr = self.get_polyfit_val(mos_sig_raw, mos_bak_raw, mos_ovr_raw)
+            predicted_mos_sig_seg_raw.append(mos_sig_raw)
+            predicted_mos_bak_seg_raw.append(mos_bak_raw)
+            predicted_mos_ovr_seg_raw.append(mos_ovr_raw)
+            predicted_mos_sig_seg.append(mos_sig)
+            predicted_mos_bak_seg.append(mos_bak)
+            predicted_mos_ovr_seg.append(mos_ovr)
+            predicted_p808_mos.append(p808_mos)
+        out_dict = {}
+        out_dict['OVRL_raw'] = np.mean(predicted_mos_ovr_seg_raw)
+        out_dict['SIG_raw'] = np.mean(predicted_mos_sig_seg_raw)
+        out_dict['BAK_raw'] = np.mean(predicted_mos_bak_seg_raw)
+        out_dict['OVRL'] = np.mean(predicted_mos_ovr_seg)
+        out_dict['SIG'] = np.mean(predicted_mos_sig_seg)
+        out_dict['BAK'] = np.mean(predicted_mos_bak_seg)
+        out_dict['P808_MOS'] = np.mean(predicted_p808_mos)
+        return out_dict
+
+
+def main():
+    SAMPLING_RATE = 16000
+    INPUT_LENGTH = 9.01
+    is_personalized_MOS = False
+    testset_dir = "../data/vad_example.wav"
+
+    compute_score = ComputeScore(is_personalized_MOS, SAMPLING_RATE, INPUT_LENGTH)
+    data = compute_score(testset_dir)
+    print(data)
+
+
+if __name__ == "__main__":
+    main()

neverlib/.history/metrics/lpc_lsp_metric_20250816015944.py

@@ -0,0 +1,128 @@
+'''
+  功能描述
+
+  计算参考语音和测试语音之间的线性预测编码-线谱对(LPC-LSP)参
+  数失真度
+
+  主要组件
+
+  预处理函数:
+  - pre_emphasis(): 预加重滤波，增强高频成分
+  - framing(): 分帧处理并应用汉明窗
+
+  LPC分析:
+  - lpc_analysis(): 使用librosa.lpc进行线性预测分析
+  - lpc_to_lsp(): LPC系数转换为线谱对参数
+
+  距离计算:
+  - lsp_mse(): 计算LSP向量间的均方误差
+  - lpc_lsp_distance(): 主函数，返回平均失真度和逐帧失真列表
+
+  技术特点
+
+  - 使用soundfile读取音频（支持多种格式）
+  - librosa进行LPC分析（替代了自定义算法）
+  - 基于LSP的频域失真测量，对量化误差敏感度更低
+  - 逐帧分析捕捉语音时变特性
+
+  应用场景
+
+  语音编码器质量评估、语音增强效果测量、语音合成质量分析
+'''
+import numpy as np
+import librosa
+import soundfile as sf
+
+def pre_emphasis(signal, coeff=0.97):
+    """预加重"""
+    return np.append(signal[0], signal[1:] - coeff * signal[:-1])
+
+def framing(signal, frame_size, frame_stride, fs):
+    """分帧 + 汉明窗"""
+    frame_length = int(round(frame_size * fs))
+    frame_step = int(round(frame_stride * fs))
+    
+    # 使用 librosa 进行分帧
+    frames = librosa.util.frame(signal, frame_length=frame_length, hop_length=frame_step, axis=0)
+    
+    # 应用汉明窗
+    hamming_window = np.hamming(frame_length)
+    frames = frames.T * hamming_window
+    
+    return frames
+
+
+def lpc_analysis(frame, order):
+    """对一帧做 LPC 分析"""
+    a = librosa.lpc(frame, order=order)
+    return a
+
+def lpc_to_lsp(a, num_points=512):
+    """
+    LPC -> LSP 转换（简易近似版，零点搜索法）
+    """
+    p = len(a) - 1
+    a = np.array(a)
+    # 构造P(z) Q(z)
+    P = np.zeros(p+1)
+    Q = np.zeros(p+1)
+    for i in range(p+1):
+        if i == 0:
+            P[i] = 1 + a[i]
+            Q[i] = 1 - a[i]
+        else:
+            P[i] = a[i] + a[p - i]
+            Q[i] = a[i] - a[p - i]
+    # 频域采样找过零点
+    w = np.linspace(0, np.pi, num_points)
+    Pw = np.polyval(P[::-1], np.cos(w))
+    Qw = np.polyval(Q[::-1], np.cos(w))
+    
+    # 找零点近似位置
+    roots_P = w[np.where(np.diff(np.sign(Pw)) != 0)]
+    roots_Q = w[np.where(np.diff(np.sign(Qw)) != 0)]
+    lsp = np.sort(np.concatenate([roots_P, roots_Q]))
+    return lsp
+
+def lsp_mse(lsp1, lsp2):
+    """计算两个 LSP 向量的均方差"""
+    return np.mean((lsp1 - lsp2) ** 2)
+
+
+def lpc_lsp_distance(ref_wav, test_wav, frame_size=0.025, frame_stride=0.01, order=12):
+    """主函数：计算 LPC-LSP 参数失真"""
+    ref_sig, fs_r = sf.read(ref_wav, dtype='float32')
+    test_sig, fs_t = sf.read(test_wav, dtype='float32')
+
+    # 预加重
+    ref_sig = pre_emphasis(ref_sig)
+    test_sig = pre_emphasis(test_sig)
+
+    # 分帧
+    ref_frames = framing(ref_sig, frame_size, frame_stride, fs_r)
+    test_frames = framing(test_sig, frame_size, frame_stride, fs_t)
+
+    # 对齐帧数（简单切到最短）
+    num_frames = min(len(ref_frames), len(test_frames))
+    ref_frames = ref_frames[:num_frames]
+    test_frames = test_frames[:num_frames]
+
+    distances = []
+    for i in range(num_frames):
+        a_ref = lpc_analysis(ref_frames[i], order)
+        a_test = lpc_analysis(test_frames[i], order)
+        lsp_ref = lpc_to_lsp(a_ref)
+        lsp_test = lpc_to_lsp(a_test)
+        # 对齐长度（简单裁切）
+        min_len = min(len(lsp_ref), len(lsp_test))
+        dist = lsp_mse(lsp_ref[:min_len], lsp_test[:min_len])
+        distances.append(dist)
+
+    return np.mean(distances), distances
+
+if __name__ == "__main__":
+    ref_file = "ref.wav"   # 参考语音文件路径
+    test_file = "test.wav" # 测试语音文件路径
+
+    avg_dist, dist_list = lpc_lsp_distance(ref_file, test_file)
+    print(f"平均 LSP MSE 失真: {avg_dist}")

neverlib/.history/metrics/lpc_lsp_metric_20250816020142.py

@@ -0,0 +1,128 @@
+'''
+  功能描述
+
+  计算参考语音和测试语音之间的线性预测编码-线谱对(LPC-LSP)参
+  数失真度
+
+  主要组件
+
+  预处理函数:
+  - pre_emphasis(): 预加重滤波，增强高频成分
+  - framing(): 分帧处理并应用汉明窗
+
+  LPC分析:
+  - lpc_analysis(): 使用librosa.lpc进行线性预测分析
+  - lpc_to_lsp(): LPC系数转换为线谱对参数
+
+  距离计算:
+  - lsp_mse(): 计算LSP向量间的均方误差
+  - lpc_lsp_distance(): 主函数，返回平均失真度和逐帧失真列表
+
+  技术特点
+
+  - 使用soundfile读取音频（支持多种格式）
+  - librosa进行LPC分析（替代了自定义算法）
+  - 基于LSP的频域失真测量，对量化误差敏感度更低
+  - 逐帧分析捕捉语音时变特性
+
+  应用场景
+
+  语音编码器质量评估、语音增强效果测量、语音合成质量分析
+'''
+import numpy as np
+import librosa
+import soundfile as sf
+
+def pre_emphasis(signal, coeff=0.97):
+    """预加重"""
+    return np.append(signal[0], signal[1:] - coeff * signal[:-1])
+
+def framing(signal, frame_size, frame_stride, fs):
+    """分帧 + 汉明窗"""
+    frame_length = int(round(frame_size * fs))
+    frame_step = int(round(frame_stride * fs))
+    
+    # 使用 librosa 进行分帧
+    frames = librosa.util.frame(signal, frame_length=frame_length, hop_length=frame_step, axis=0)
+    
+    # 应用汉明窗
+    hamming_window = np.hamming(frame_length)
+    frames = frames.T * hamming_window
+    
+    return frames
+
+
+def lpc_analysis(frame, order):
+    """对一帧做 LPC 分析"""
+    a = librosa.lpc(frame, order=order)
+    return a
+
+def lpc_to_lsp(a, num_points=512):
+    """
+    LPC -> LSP 转换（简易近似版，零点搜索法）
+    """
+    p = len(a) - 1
+    a = np.array(a)
+    # 构造P(z) Q(z)
+    P = np.zeros(p+1)
+    Q = np.zeros(p+1)
+    for i in range(p+1):
+        if i == 0:
+            P[i] = 1 + a[i]
+            Q[i] = 1 - a[i]
+        else:
+            P[i] = a[i] + a[p - i]
+            Q[i] = a[i] - a[p - i]
+    # 频域采样找过零点
+    w = np.linspace(0, np.pi, num_points)
+    Pw = np.polyval(P[::-1], np.cos(w))
+    Qw = np.polyval(Q[::-1], np.cos(w))
+    
+    # 找零点近似位置
+    roots_P = w[np.where(np.diff(np.sign(Pw)) != 0)]
+    roots_Q = w[np.where(np.diff(np.sign(Qw)) != 0)]
+    lsp = np.sort(np.concatenate([roots_P, roots_Q]))
+    return lsp
+
+def lsp_mse(lsp1, lsp2):
+    """计算两个 LSP 向量的均方差"""
+    return np.mean((lsp1 - lsp2) ** 2)
+
+
+def lpc_lsp_distance(ref_wav, test_wav, frame_size=0.025, frame_stride=0.01, order=12):
+    """主函数：计算 LPC-LSP 参数失真"""
+    ref_sig, fs_r = sf.read(ref_wav, dtype='float32')
+    test_sig, fs_t = sf.read(test_wav, dtype='float32')
+
+    # 预加重
+    ref_sig = pre_emphasis(ref_sig)
+    test_sig = pre_emphasis(test_sig)
+
+    # 分帧
+    ref_frames = framing(ref_sig, frame_size, frame_stride, fs_r)
+    test_frames = framing(test_sig, frame_size, frame_stride, fs_t)
+
+    # 对齐帧数（简单切到最短）
+    num_frames = min(len(ref_frames), len(test_frames))
+    ref_frames = ref_frames[:num_frames]
+    test_frames = test_frames[:num_frames]
+
+    distances = []
+    for i in range(num_frames):
+        a_ref = lpc_analysis(ref_frames[i], order)
+        a_test = lpc_analysis(test_frames[i], order)
+        lsp_ref = lpc_to_lsp(a_ref)
+        lsp_test = lpc_to_lsp(a_test)
+        # 对齐长度（简单裁切）
+        min_len = min(len(lsp_ref), len(lsp_test))
+        dist = lsp_mse(lsp_ref[:min_len], lsp_test[:min_len])
+        distances.append(dist)
+
+    return np.mean(distances), distances
+
+if __name__ == "__main__":
+    ref_file = "../"   # 参考语音文件路径
+    test_file = "test.wav" # 测试语音文件路径
+
+    avg_dist, dist_list = lpc_lsp_distance(ref_file, test_file)
+    print(f"平均 LSP MSE 失真: {avg_dist}")

neverlib/.history/metrics/lpc_lsp_metric_20250816020156.py

@@ -0,0 +1,128 @@
+'''
+  功能描述
+
+  计算参考语音和测试语音之间的线性预测编码-线谱对(LPC-LSP)参
+  数失真度
+
+  主要组件
+
+  预处理函数:
+  - pre_emphasis(): 预加重滤波，增强高频成分
+  - framing(): 分帧处理并应用汉明窗
+
+  LPC分析:
+  - lpc_analysis(): 使用librosa.lpc进行线性预测分析
+  - lpc_to_lsp(): LPC系数转换为线谱对参数
+
+  距离计算:
+  - lsp_mse(): 计算LSP向量间的均方误差
+  - lpc_lsp_distance(): 主函数，返回平均失真度和逐帧失真列表
+
+  技术特点
+
+  - 使用soundfile读取音频（支持多种格式）
+  - librosa进行LPC分析（替代了自定义算法）
+  - 基于LSP的频域失真测量，对量化误差敏感度更低
+  - 逐帧分析捕捉语音时变特性
+
+  应用场景
+
+  语音编码器质量评估、语音增强效果测量、语音合成质量分析
+'''
+import numpy as np
+import librosa
+import soundfile as sf
+
+def pre_emphasis(signal, coeff=0.97):
+    """预加重"""
+    return np.append(signal[0], signal[1:] - coeff * signal[:-1])
+
+def framing(signal, frame_size, frame_stride, fs):
+    """分帧 + 汉明窗"""
+    frame_length = int(round(frame_size * fs))
+    frame_step = int(round(frame_stride * fs))
+    
+    # 使用 librosa 进行分帧
+    frames = librosa.util.frame(signal, frame_length=frame_length, hop_length=frame_step, axis=0)
+    
+    # 应用汉明窗
+    hamming_window = np.hamming(frame_length)
+    frames = frames.T * hamming_window
+    
+    return frames
+
+
+def lpc_analysis(frame, order):
+    """对一帧做 LPC 分析"""
+    a = librosa.lpc(frame, order=order)
+    return a
+
+def lpc_to_lsp(a, num_points=512):
+    """
+    LPC -> LSP 转换（简易近似版，零点搜索法）
+    """
+    p = len(a) - 1
+    a = np.array(a)
+    # 构造P(z) Q(z)
+    P = np.zeros(p+1)
+    Q = np.zeros(p+1)
+    for i in range(p+1):
+        if i == 0:
+            P[i] = 1 + a[i]
+            Q[i] = 1 - a[i]
+        else:
+            P[i] = a[i] + a[p - i]
+            Q[i] = a[i] - a[p - i]
+    # 频域采样找过零点
+    w = np.linspace(0, np.pi, num_points)
+    Pw = np.polyval(P[::-1], np.cos(w))
+    Qw = np.polyval(Q[::-1], np.cos(w))
+    
+    # 找零点近似位置
+    roots_P = w[np.where(np.diff(np.sign(Pw)) != 0)]
+    roots_Q = w[np.where(np.diff(np.sign(Qw)) != 0)]
+    lsp = np.sort(np.concatenate([roots_P, roots_Q]))
+    return lsp
+
+def lsp_mse(lsp1, lsp2):
+    """计算两个 LSP 向量的均方差"""
+    return np.mean((lsp1 - lsp2) ** 2)
+
+
+def lpc_lsp_distance(ref_wav, test_wav, frame_size=0.025, frame_stride=0.01, order=12):
+    """主函数：计算 LPC-LSP 参数失真"""
+    ref_sig, fs_r = sf.read(ref_wav, dtype='float32')
+    test_sig, fs_t = sf.read(test_wav, dtype='float32')
+
+    # 预加重
+    ref_sig = pre_emphasis(ref_sig)
+    test_sig = pre_emphasis(test_sig)
+
+    # 分帧
+    ref_frames = framing(ref_sig, frame_size, frame_stride, fs_r)
+    test_frames = framing(test_sig, frame_size, frame_stride, fs_t)
+
+    # 对齐帧数（简单切到最短）
+    num_frames = min(len(ref_frames), len(test_frames))
+    ref_frames = ref_frames[:num_frames]
+    test_frames = test_frames[:num_frames]
+
+    distances = []
+    for i in range(num_frames):
+        a_ref = lpc_analysis(ref_frames[i], order)
+        a_test = lpc_analysis(test_frames[i], order)
+        lsp_ref = lpc_to_lsp(a_ref)
+        lsp_test = lpc_to_lsp(a_test)
+        # 对齐长度（简单裁切）
+        min_len = min(len(lsp_ref), len(lsp_test))
+        dist = lsp_mse(lsp_ref[:min_len], lsp_test[:min_len])
+        distances.append(dist)
+
+    return np.mean(distances), distances
+
+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}")

neverlib/.history/metrics/lpc_lsp_metric_20250816020554.py

@@ -0,0 +1,130 @@
+'''
+  功能描述
+
+  计算参考语音和测试语音之间的线性预测编码-线谱对(LPC-LSP)参
+  数失真度
+
+  主要组件
+
+  预处理函数:
+  - pre_emphasis(): 预加重滤波，增强高频成分
+  - framing(): 分帧处理并应用汉明窗
+
+  LPC分析:
+  - lpc_analysis(): 使用librosa.lpc进行线性预测分析
+  - lpc_to_lsp(): LPC系数转换为线谱对参数
+
+  距离计算:
+  - lsp_mse(): 计算LSP向量间的均方误差
+  - lpc_lsp_distance(): 主函数，返回平均失真度和逐帧失真列表
+
+  技术特点
+
+  - 使用soundfile读取音频（支持多种格式）
+  - librosa进行LPC分析（替代了自定义算法）
+  - 基于LSP的频域失真测量，对量化误差敏感度更低
+  - 逐帧分析捕捉语音时变特性
+
+  应用场景
+
+  语音编码器质量评估、语音增强效果测量、语音合成质量分析
+'''
+import numpy as np
+import librosa
+import soundfile as sf
+
+def pre_emphasis(signal, coeff=0.97):
+    """预加重"""
+    return np.append(signal[0], signal[1:] - coeff * signal[:-1])
+
+def framing(signal, frame_size, frame_stride, fs):
+    """分帧 + 汉明窗"""
+    frame_length = int(round(frame_size * fs))
+    frame_step = int(round(frame_stride * fs))
+    
+    # 使用 librosa 进行分帧
+    frames = librosa.util.frame(signal, frame_length=frame_length, hop_length=frame_step, axis=0)
+    
+    # frames的形状是(num_frames, frame_length)
+    hamming_window = np.hamming(frame_length)
+    frames = frames * hamming_window  # 直接广播
+    
+    return frames
+
+
+def lpc_analysis(frame, order):
+    """对一帧做 LPC 分析"""
+    a = librosa.lpc(frame, order=order)
+    return a
+
+def lpc_to_lsp(a, num_points=512):
+    """
+    LPC -> LSP 转换（简易近似版，零点搜索法）
+    """
+    p = len(a) - 1
+    a = np.array(a)
+    # 构造P(z) Q(z)
+    P = np.zeros(p+1)
+    Q = np.zeros(p+1)
+    for i in range(p+1):
+        if i == 0:
+            P[i] = 1 + a[i]
+            Q[i] = 1 - a[i]
+        else:
+            P[i] = a[i] + a[p - i]
+            Q[i] = a[i] - a[p - i]
+    # 频域采样找过零点
+    w = np.linspace(0, np.pi, num_points)
+    Pw = np.polyval(P[::-1], np.cos(w))
+    Qw = np.polyval(Q[::-1], np.cos(w))
+    
+    # 找零点近似位置
+    roots_P = w[np.where(np.diff(np.sign(Pw)) != 0)]
+    roots_Q = w[np.where(np.diff(np.sign(Qw)) != 0)]
+    lsp = np.sort(np.concatenate([roots_P, roots_Q]))
+    return lsp
+
+def lsp_mse(lsp1, lsp2):
+    """计算两个 LSP 向量的均方差"""
+    return np.mean((lsp1 - lsp2) ** 2)
+
+
+def lpc_lsp_distance(ref_wav, test_wav, frame_size=0.025, frame_stride=0.01, order=12):
+    """主函数：计算 LPC-LSP 参数失真"""
+    ref_sig, fs_r = sf.read(ref_wav, dtype='float32')
+    test_sig, fs_t = sf.read(test_wav, dtype='float32')
+
+    # 预加重
+    ref_sig = pre_emphasis(ref_sig)
+    test_sig = pre_emphasis(test_sig)
+
+    # 分帧
+    ref_frames = framing(ref_sig, frame_size, frame_stride, fs_r)
+    test_frames = framing(test_sig, frame_size, frame_stride, fs_t)
+
+    # 对齐帧数（简单切到最短）
+    num_frames = min(len(ref_frames), len(test_frames))
+    ref_frames = ref_frames[:num_frames]
+    test_frames = test_frames[:num_frames]
+
+    distances = []
+    for i in range(num_frames):
+        a_ref = lpc_analysis(ref_frames[i], order)
+        a_test = lpc_analysis(test_frames[i], order)
+        lsp_ref = lpc_to_lsp(a_ref)
+        lsp_test = lpc_to_lsp(a_test)
+        # 对齐长度（简单裁切）
+        min_len = min(len(lsp_ref), len(lsp_test))
+        # dist = lsp_mse(lsp_ref[:min_len], lsp_test[:min_len])
+        # 计算两个 LSP 向量的均方差
+        dist = np.mean((lsp_ref[:min_len] - lsp_test[:min_len]) ** 2)
+        distances.append(dist)
+
+    return np.mean(distances), distances
+
+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}")