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

neverlib/filter/core.py

@@ -0,0 +1,339 @@
+'''
+Author: 凌逆战 | Never
+Date: 2025-08-04 16:25:00
+Description: EQ滤波器
+type(fc, gain, Q) 
+
+enum IIR_BIQUARD_TYPE {
+    IIR_BIQUARD_PASS = 0,   // pass through
+    IIR_BIQUARD_RAW,        // raw filter
+    IIR_BIQUARD_LPF,        // 低通滤波器 low pass filter
+    IIR_BIQUARD_HPF,        // 高通滤波器 high pass filter
+    IIR_BIQUARD_BPF0,       // 带通滤波器 band pass filter, constant skirt gain, peak gain = Q
+    IIR_BIQUARD_BPF1,       // 带通滤波器 band pass filter, const 0 dB peak gain
+    IIR_BIQUARD_NOTCH,      // 陷波滤波器 notch filter
+    IIR_BIQUARD_APF,        // 全通滤波器 allpass filter
+    IIR_BIQUARD_PEAKINGEQ,  // 峰值滤波器 peakingEQ
+    IIR_BIQUARD_LOWSHELF,   // 低切滤波器 low shelf filter
+    IIR_BIQUARD_HIGHSHELF,  // 高切滤波器 high shelf filter
+    IIR_BIQUARD_QTY         // number of biquard types
+};
+'''
+import random
+import numpy as np
+from scipy import signal
+
+
+class EQFilter():
+    def __init__(self, fs=16000):
+        self.fs = fs
+
+    def LowpassFilter(self, fc, Q=1 / np.sqrt(2.0)):
+        """ 低通滤波器(Low Pass Filter) 
+        LPF: H(s) = 1 / (s^2 + s/Q + 1)
+
+        b0 = (1 - cos(w0))/2;
+        b1 = 1 - cos(w0);
+        b2 = (1 - cos(w0))/2;
+        a0 = 1 + alpha;
+        a1 = -2*cos(w0);
+        a2 = 1 - alpha;
+        """
+        # 中间变量
+        w0 = 2.0 * np.pi * fc / self.fs  # 角频率
+        cos_w0 = np.cos(w0)  # cos(w0)
+        sin_w0 = np.sin(w0)  # sin(w0)
+        alpha = sin_w0 / (2.0 * Q)  # alpha
+        # ---------------------------------------------
+        b0 = (1.0 - cos_w0) / 2.0
+        b1 = 1.0 - cos_w0
+        b2 = (1.0 - cos_w0) / 2.0
+        a0 = 1.0 + alpha
+        a1 = -2.0 * cos_w0
+        a2 = 1.0 - alpha
+        numerator_B = np.array([b0, b1, b2], dtype=np.float32)
+        denominator_A = np.array([a0, a1, a2], dtype=np.float32)
+        return numerator_B / a0, denominator_A / a0
+
+    def HighpassFilter(self, fc, Q=1 / np.sqrt(2)):
+        """ 高通滤波器(High Pass Filter) 
+        HPF: $H(s)=\frac{s^2}{s^2 + s/Q + 1}$
+            b0 = (1 + cos(w0))/2
+            b1 = -(1 + cos(w0))
+            b2 = (1 + cos(w0))/2
+            a0 = 1 + alpha
+            a1 = -2*cos(w0)
+            a2 = 1 - alpha
+        """
+        # 中间变量
+        w0 = 2.0 * np.pi * fc / self.fs  # 角频率
+        cos_w0 = np.cos(w0)  # cos(w0)
+        sin_w0 = np.sin(w0)  # sin(w0)
+        alpha = sin_w0 / (2.0 * Q)  # alpha
+        # ---------------------------------------------
+        b0 = (1.0 + cos_w0) / 2.0
+        b1 = -(1.0 + cos_w0)
+        b2 = (1.0 + cos_w0) / 2.0
+        a0 = 1.0 + alpha
+        a1 = -2.0 * cos_w0
+        a2 = 1.0 - alpha
+        numerator_B = np.array([b0, b1, b2], dtype=np.float32)
+        denominator_A = np.array([a0, a1, a2], dtype=np.float32)
+        return numerator_B / a0, denominator_A / a0
+
+    def BandpassFilter_Q(self, fc, Q):
+        """带通 Band Pass Filter (增益 = Q)
+        BPF: H(s) = s / (s^2 + s/Q + 1) (constant skirt gain, peak gain = Q)
+            b0 =   sin(w0)/2  =   Q*alpha
+            b1 =   0
+            b2 =  -sin(w0)/2  =  -Q*alpha
+            a0 =   1 + alpha
+            a1 =  -2*cos(w0)
+            a2 =   1 - alpha
+        """
+        # 中间变量
+        w0 = 2.0 * np.pi * fc / self.fs  # 角频率
+        cos_w0 = np.cos(w0)  # cos(w0)
+        sin_w0 = np.sin(w0)  # sin(w0)
+        alpha = sin_w0 / (2.0 * Q)  # alpha
+        # ---------------------------------------------
+        b0 = sin_w0 / 2.0  # Q*alpha
+        b1 = 0.0
+        b2 = -sin_w0 / 2.0  # -Q*alpha
+        a0 = 1.0 + alpha
+        a1 = -2.0 * cos_w0
+        a2 = 1.0 - alpha
+        numerator_B = np.array([b0, b1, b2], dtype=np.float32)
+        denominator_A = np.array([a0, a1, a2], dtype=np.float32)
+        return numerator_B / a0, denominator_A / a0
+
+    def BandpassFilter_0dB(self, fc, Q=1 / np.sqrt(2)):
+        """带通 Band Pass Filter(0 db增益)
+        BPF: H(s) = (s/Q) / (s^2 + s/Q + 1) (constant 0 dB peak gain)
+            b0 =   alpha
+            b1 =   0
+            b2 =  -alpha
+            a0 =   1 + alpha
+            a1 =  -2*cos(w0)
+            a2 =   1 - alpha
+        """
+        # 中间变量
+        w0 = 2.0 * np.pi * fc / self.fs  # 角频率
+        cos_w0 = np.cos(w0)  # cos(w0)
+        sin_w0 = np.sin(w0)  # sin(w0)
+        alpha = sin_w0 / (2.0 * Q)  # alpha
+        # ---------------------------------------------
+        b0 = alpha
+        b1 = 0.0
+        b2 = -alpha
+        a0 = 1.0 + alpha
+        a1 = -2.0 * cos_w0
+        a2 = 1.0 - alpha
+        numerator_B = np.array([b0, b1, b2], dtype=np.float32)
+        denominator_A = np.array([a0, a1, a2], dtype=np.float32)
+        return numerator_B / a0, denominator_A / a0
+
+    def NotchFilter(self, fc, Q=1 / np.sqrt(2)):
+        """Notch滤波器
+        notch: H(s) = (s^2 + 1) / (s^2 + s/Q + 1)$
+            b0 =   1
+            b1 =  -2*cos(w0)
+            b2 =   1
+            a0 =   1 + alpha
+            a1 =  -2*cos(w0)
+            a2 =   1 - alpha
+        """
+        # 中间变量
+        w0 = 2.0 * np.pi * fc / self.fs  # 角频率
+        cos_w0 = np.cos(w0)  # cos(w0)
+        sin_w0 = np.sin(w0)  # sin(w0)
+        alpha = sin_w0 / (2.0 * Q)  # alpha
+        # ---------------------------------------------
+        b0 = 1.0
+        b1 = -2.0 * cos_w0
+        b2 = 1.0
+        a0 = 1.0 + alpha
+        a1 = -2.0 * cos_w0
+        a2 = 1.0 - alpha
+        numerator_B = np.array([b0, b1, b2], dtype=np.float32)
+        denominator_A = np.array([a0, a1, a2], dtype=np.float32)
+        return numerator_B / a0, denominator_A / a0
+
+    def AllpassFilter(self, fc, Q=1 / np.sqrt(2)):
+        """全通 All Pass Filter
+        APF: H(s) = (s^2 - s/Q + 1) / (s^2 + s/Q + 1)$
+            b0 =   1 - alpha
+            b1 =  -2*cos(w0)
+            b2 =   1 + alpha
+            a0 =   1 + alpha
+            a1 =  -2*cos(w0)
+            a2 =   1 - alpha
+        """
+        # 中间变量
+        w0 = 2.0 * np.pi * fc / self.fs  # 角频率
+        cos_w0 = np.cos(w0)  # cos(w0)
+        sin_w0 = np.sin(w0)  # sin(w0)
+        alpha = sin_w0 / (2.0 * Q)  # alpha
+        # ---------------------------------------------
+        b0 = 1.0 - alpha
+        b1 = -2.0 * cos_w0
+        b2 = 1.0 + alpha
+        a0 = 1.0 + alpha
+        a1 = -2.0 * cos_w0
+        a2 = 1.0 - alpha
+        numerator_B = np.array([b0, b1, b2], dtype=np.float32)
+        denominator_A = np.array([a0, a1, a2], dtype=np.float32)
+        return numerator_B / a0, denominator_A / a0
+
+    def PeakingFilter(self, fc, dBgain, Q=1 / np.sqrt(2)):
+        """峰值滤波器
+        peakingEQ: H(s) = (s^2 + s*(A/Q) + 1) / (s^2 + s/(A*Q) + 1)
+            b0 =   1 + alpha*A
+            b1 =  -2*cos(w0)
+            b2 =   1 - alpha*A
+            a0 =   1 + alpha/A
+            a1 =  -2*cos(w0)
+            a2 =   1 - alpha/A
+        """
+        # 中间变量
+        w0 = 2.0 * np.pi * fc / self.fs  # 角频率
+        # cos_w0 = np.cos(w0)  # cos(w0)
+        sin_w0 = np.sin(w0)  # sin(w0)
+        alpha = sin_w0 / (2.0 * Q)  # alpha
+        # gain、A 仅用于峰值和shelf滤波器
+        dBgain = round(float(dBgain), 3)
+        A = 10 ** (dBgain / 40)
+        # ---------------------------------------------
+        b0 = 1 + alpha * A
+        b1 = -2 * np.cos(w0)
+        b2 = 1 - alpha * A
+        a0 = 1 + alpha / A
+        a1 = -2 * np.cos(w0)
+        a2 = 1 - alpha / A
+        numerator_B = np.array([b0, b1, b2], dtype=np.float32)
+        denominator_A = np.array([a0, a1, a2], dtype=np.float32)
+        return numerator_B / a0, denominator_A / a0
+
+    def LowshelfFilter(self, fc, dBgain, Q=1 / np.sqrt(2)):
+        """低切滤波器
+        lowShelf: H(s) = A * (s^2 + (sqrt(A)/Q)*s + A)/(A*s^2 + (sqrt(A)/Q)*s + 1)
+            b0 =    A*( (A+1) - (A-1)*cos(w0) + 2*sqrt(A)*alpha )
+            b1 =  2*A*( (A-1) - (A+1)*cos(w0)                   )
+            b2 =    A*( (A+1) - (A-1)*cos(w0) - 2*sqrt(A)*alpha )
+            a0 =        (A+1) + (A-1)*cos(w0) + 2*sqrt(A)*alpha
+            a1 =   -2*( (A-1) + (A+1)*cos(w0)                   )
+            a2 =        (A+1) + (A-1)*cos(w0) - 2*sqrt(A)*alpha
+        """
+        # 中间变量
+        w0 = 2.0 * np.pi * fc / self.fs  # 角频率
+        cos_w0 = np.cos(w0)  # cos(w0)
+        sin_w0 = np.sin(w0)  # sin(w0)
+        alpha = sin_w0 / (2.0 * Q)  # alpha
+        # gain、A 仅用于峰值和shelf滤波器
+        dBgain = round(float(dBgain), 3)
+        A = 10.0 ** (dBgain / 40.0)
+        # ---------------------------------------------
+        b0 = A * ((A + 1) - (A - 1) * cos_w0 + 2 * np.sqrt(A) * alpha)
+        b1 = 2 * A * ((A - 1) - (A + 1) * cos_w0)
+        b2 = A * ((A + 1) - (A - 1) * cos_w0 - 2 * np.sqrt(A) * alpha)
+        a0 = (A + 1) + (A - 1) * cos_w0 + 2 * np.sqrt(A) * alpha
+        a1 = -2 * ((A - 1) + (A + 1) * cos_w0)
+        a2 = (A + 1) + (A - 1) * cos_w0 - 2 * np.sqrt(A) * alpha
+        numerator_B = np.array([b0, b1, b2], dtype=np.float32)
+        denominator_A = np.array([a0, a1, a2], dtype=np.float32)
+        return numerator_B / a0, denominator_A / a0
+
+    def HighshelfFilter(self, fc, dBgain, Q=1 / np.sqrt(2)):
+        """高切滤波器
+        highShelf: H(s) = A * (A*s^2 + (sqrt(A)/Q)*s + 1)/(s^2 + (sqrt(A)/Q)*s + A)
+            b0 =    A*( (A+1) + (A-1)*cos(w0) + 2*sqrt(A)*alpha )
+            b1 = -2*A*( (A-1) + (A+1)*cos(w0)                   )
+            b2 =    A*( (A+1) + (A-1)*cos(w0) - 2*sqrt(A)*alpha )
+            a0 =        (A+1) - (A-1)*cos(w0) + 2*sqrt(A)*alpha
+            a1 =    2*( (A-1) - (A+1)*cos(w0)                   )
+            a2 =        (A+1) - (A-1)*cos(w0) - 2*sqrt(A)*alpha
+        """
+        # 中间变量
+        w0 = 2.0 * np.pi * fc / self.fs  # 角频率
+        cos_w0 = np.cos(w0)  # cos(w0)
+        sin_w0 = np.sin(w0)  # sin(w0)
+        alpha = sin_w0 / (2.0 * Q)  # alpha
+        # gain、A 仅用于峰值和shelf滤波器
+        dBgain = round(float(dBgain), 3)
+        A = 10.0 ** (dBgain / 40.0)
+        # ---------------------------------------------
+        b0 = A * ((A + 1) + (A - 1) * cos_w0 + 2 * np.sqrt(A) * alpha)
+        b1 = -2 * A * ((A - 1) + (A + 1) * cos_w0)
+        b2 = A * ((A + 1) + (A - 1) * cos_w0 - 2 * np.sqrt(A) * alpha)
+        a0 = (A + 1) - (A - 1) * cos_w0 + 2 * np.sqrt(A) * alpha
+        a1 = 2 * ((A - 1) - (A + 1) * cos_w0)
+        a2 = (A + 1) - (A - 1) * cos_w0 - 2 * np.sqrt(A) * alpha
+        numerator_B = np.array([b0, b1, b2], dtype=np.float32)
+        denominator_A = np.array([a0, a1, a2], dtype=np.float32)
+        return numerator_B / a0, denominator_A / a0
+
+
+def eq_process(sig, b_list, a_list, ratio):
+    """ psap eq增强
+    :param sig: input signal with size [T] or [T, C]
+    :param b_list: 滤波器系数列表
+    :param a_list: 滤波器系数列表
+    :param ratio: 0-1, processing ratio
+    :return: [T] when ipt.shape is [T]; [T, C] when ipt.shape is [T, C]
+    """
+    if len(sig.shape) == 1:
+        sig.shape = -1, 1
+    assert len(sig.shape) == 2, f"input signal's shape must be 2, but {sig.shape} now!"
+    sig_eq = sig.copy()
+    if random.random() < ratio:
+        # 逐个应用滤波器
+        for b, a in zip(b_list, a_list):
+            sig_eq = signal.lfilter(b, a, sig_eq, axis=0)
+    return sig_eq
+
+
+def eq_process_test():
+    import soundfile as sf
+
+    EQ_Coef = [
+        ([1.5023072, -1.0912886, 0.1981803], [1., -1.3417218, 0.4500543]),  # f0 = 80, gain = -20, q = 1
+        ([1.2288871, -1.173879, 0.18292512], [1., -1.173879, 0.4118123]),  # f0 = 100, gain = -10, q = 1
+    ]
+
+    wav, wav_sr = sf.read("./white.wav", dtype="float32", always_2d=True)
+
+    wav = eq_process(wav, EQ_Coef, ratio=1)
+
+    sf.write("./white_eq.wav", wav, wav_sr)
+
+
+def EQ_test():
+    """
+    lowshelf滤波器 freq=1.5kHz, gain=15dB, Q=0.5
+    b: [ 1.5023072 -1.0912886  0.1981803]
+    a: [ 1.        -1.3417218  0.4500543]
+
+    peak freq=1.5kHz, gain=5dB, Q=0.5
+    b: [ 1.2288871  -1.173879    0.18292512]
+    a: [ 1.        -1.173879   0.4118123]
+    """
+    import numpy as np
+    import matplotlib.pyplot as plt
+    from scipy import signal
+
+    fs = 16000
+
+    # b, a = LowshelfFilter(1500, 15, Q=0.5)
+    b, a = PeakingFilter(1500, 5, Q=0.5)
+    print(b)
+    print(a)
+
+    w, h = signal.freqz(b, a)  # 根据系数计算滤波器的频率响应, w是角频率, h是频率响应
+    plt.plot(0.5 * fs * w / np.pi, 20 * np.log10(h))  # 0.5*fs*w/np.pi 为频率
+    plt.title('Butterworth filter frequency response')
+    plt.xlabel('Frequency [Hz]')
+    plt.ylabel('Amplitude [dB]')
+    plt.grid(which='both', axis='both')  # 显示网格
+    # 画红色的垂直线, 标记截止频率
+    plt.xscale('log')  # x轴对数化
+    plt.show()

neverlib/metrics/dnsmos.py

@@ -0,0 +1,160 @@
+'''
+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
+
+SAMPLING_RATE = 16000
+INPUT_LENGTH = 9.01
+
+
+class ComputeScore:
+    def __init__(self, primary_model_path, p808_model_path) -> None:
+        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, sr=16000, to_db=True):
+        mel_spec = librosa.feature.melspectrogram(y=audio, sr=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, is_personalized_MOS):
+        if 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 = p_sig(sig)
+        bak_poly = p_bak(bak)
+        ovr_poly = p_ovr(ovr)
+
+        return sig_poly, bak_poly, ovr_poly
+
+    def __call__(self, fpath, sampling_rate, is_personalized_MOS):
+        aud, input_fs = sf.read(fpath)
+        fs = sampling_rate
+        if input_fs != fs:
+            audio = librosa.resample(aud, input_fs, fs)
+        else:
+            audio = aud
+        actual_audio_len = len(audio)
+        len_samples = int(INPUT_LENGTH*fs)
+        while len(audio) < len_samples:
+            audio = np.append(audio, audio)
+
+        num_hops = int(np.floor(len(audio)/fs) - INPUT_LENGTH)+1
+        hop_len_samples = fs
+        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):
+            audio_seg = audio[int(idx*hop_len_samples): int((idx+INPUT_LENGTH)*hop_len_samples)]
+            if len(audio_seg) < len_samples:
+                continue
+
+            input_features = np.array(audio_seg).astype('float32')[np.newaxis, :]
+            p808_input_features = np.array(self.audio_melspec(audio=audio_seg[:-160])).astype('float32')[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, is_personalized_MOS)
+            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)
+
+        clip_dict = {'filename': fpath, 'len_in_sec': actual_audio_len/fs, 'sr': fs}
+        clip_dict['num_hops'] = num_hops
+        clip_dict['OVRL_raw'] = np.mean(predicted_mos_ovr_seg_raw)
+        clip_dict['SIG_raw'] = np.mean(predicted_mos_sig_seg_raw)
+        clip_dict['BAK_raw'] = np.mean(predicted_mos_bak_seg_raw)
+        clip_dict['OVRL'] = np.mean(predicted_mos_ovr_seg)
+        clip_dict['SIG'] = np.mean(predicted_mos_sig_seg)
+        clip_dict['BAK'] = np.mean(predicted_mos_bak_seg)
+        clip_dict['P808_MOS'] = np.mean(predicted_p808_mos)
+        return clip_dict
+
+
+def main(args):
+    models = glob.glob(os.path.join(args.testset_dir, "*"))
+    audio_clips_list = []
+    p808_model_path = os.path.join('DNSMOS', 'model_v8.onnx')
+
+    if args.personalized_MOS:
+        primary_model_path = os.path.join('pDNSMOS', 'sig_bak_ovr.onnx')
+    else:
+        primary_model_path = os.path.join('DNSMOS', 'sig_bak_ovr.onnx')
+
+    compute_score = ComputeScore(primary_model_path, p808_model_path)
+
+    rows = []
+    clips = []
+    clips = glob.glob(os.path.join(args.testset_dir, "*.wav"))
+    is_personalized_eval = args.personalized_MOS
+    desired_fs = SAMPLING_RATE
+    for m in tqdm(models):
+        max_recursion_depth = 10
+        audio_path = os.path.join(args.testset_dir, m)
+        audio_clips_list = glob.glob(os.path.join(audio_path, "*.wav"))
+        while len(audio_clips_list) == 0 and max_recursion_depth > 0:
+            audio_path = os.path.join(audio_path, "**")
+            audio_clips_list = glob.glob(os.path.join(audio_path, "*.wav"))
+            max_recursion_depth -= 1
+        clips.extend(audio_clips_list)
+
+    with concurrent.futures.ThreadPoolExecutor() as executor:
+        future_to_url = {executor.submit(compute_score, clip, desired_fs, is_personalized_eval): clip for clip in clips}
+        for future in tqdm(concurrent.futures.as_completed(future_to_url)):
+            clip = future_to_url[future]
+            try:
+                data = future.result()
+            except Exception as exc:
+                print('%r generated an exception: %s' % (clip, exc))
+            else:
+                rows.append(data)
+
+    df = pd.DataFrame(rows)
+    if args.csv_path:
+        csv_path = args.csv_path
+        df.to_csv(csv_path)
+    else:
+        print(df.describe())
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument('-t', "--testset_dir", default='.',
+                        help='Path to the dir containing audio clips in .wav to be evaluated')
+    parser.add_argument('-o', "--csv_path", default=None, help='Dir to the csv that saves the results')
+    parser.add_argument('-p', "--personalized_MOS", action='store_true',
+                        help='Flag to indicate if personalized MOS score is needed or regular')
+
+    args = parser.parse_args()
+
+    main(args)

neverlib/metrics/snr.py

@@ -0,0 +1,177 @@
+import sys
+sys.path.append("../")
+import librosa
+import numpy as np
+from vad.utils import vad2nad
+
+
+def get_snr(speech, noise):
+    """计算信噪比
+    Args:
+        speech: 语音音频
+        noise: 噪声音频
+    Returns:
+        snr: 信噪比
+    """
+    assert speech.ndim == noise.ndim, "speech和noise的维度不一样"
+
+    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)
+
+    return get_snr(speech, noise)
+
+
+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: {SegSNR(speech, noisy, 100, 50):.2f} dB")
+    print(f"PSNR: {PSNR(speech, noisy):.2f} dB")