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

neverlib/metrics/snr.py

@@ -0,0 +1,184 @@
+import sys
+sys.path.append("../")
+import librosa
+import numpy as np
+from neverlib.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)
+
+    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/metrics/spec.py

@@ -0,0 +1,136 @@
+'''
+Author: 凌逆战 | Never
+Date: 2025-08-16 13:51:57
+Description: 音频信号频域客观度量指标计算工具
+主要功能:
+1. SD (Spectral Distance) - 频谱距离
+   - 计算两个音频信号在频域上的差异程度
+   - 适用于音频质量评估和信号相似性分析
+
+2. LSD (Log-Spectral Distance) - 对数谱距离
+   - 在对数功率谱域计算信号距离
+   - 更符合人耳听觉特性，常用于语音质量评估
+
+3. MCD (Mel-Cepstral Distance) - 梅尔倒谱距离
+   - 基于MFCC特征的音频相似性度量
+   - 广泛应用于语音合成、语音识别等任务
+'''
+
+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):
+    """
+    计算两个音频信号之间的频谱距离 (Spectral Distance)。
+    该指标衡量两个信号在频域上的差异程度。
+    Args:
+        ref_wav (np.ndarray): 参考音频信号 (一维数组)
+        test_wav (np.ndarray): 测试音频信号 (一维数组)
+        n_fft (int): FFT点数，决定频率分辨率，默认为2048
+        hop_length (int): 帧移，决定时间分辨率，默认为512
+        win_length (int, optional): 窗长，如果为None则默认为n_fft
+    Returns:
+        float: 频谱距离值，值越小表示两个信号越相似
+    """
+    assert len(ref_wav) == len(test_wav), "输入信号长度必须相同"
+    
+    # 计算短时傅里叶变换
+    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)
+    
+    # 计算频谱距离：均方根误差
+    spec_diff = ref_spec - test_spec
+    squared_diff = np.abs(spec_diff) ** 2
+    mean_squared_diff = np.mean(squared_diff)
+    sd_value = np.sqrt(mean_squared_diff)
+    
+    return sd_value
+
+
+
+
+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, n_mfcc=13):
+    """
+    计算两个音频信号之间的梅尔倒谱距离 (Mel-Cepstral Distance, MCD)。
+    该指标常用于语音合成质量评估，值越小表示两个信号越相似。
+
+    Args:
+        ref_wav (np.ndarray): 参考音频信号 (一维数组)
+        test_wav (np.ndarray): 测试音频信号 (一维数组)
+        sr (int): 采样率，默认为16000Hz
+        n_mfcc (int): MFCC系数个数，默认为13
+
+    Returns:
+        float: 梅尔倒谱距离值，值越小表示两个信号越相似
+
+    """
+    assert len(ref_wav) == len(test_wav), "输入信号长度必须相同"
+
+    # 计算MFCC特征
+    ref_mfcc = librosa.feature.mfcc(y=ref_wav, sr=sr, n_mfcc=n_mfcc)
+    test_mfcc = librosa.feature.mfcc(y=test_wav, sr=sr, n_mfcc=n_mfcc)
+    
+    # 计算MCD (跳过0阶系数，因为0阶主要表示能量)
+    diff = ref_mfcc[1:] - test_mfcc[1:]
+    mcd_value = (10.0 / np.log(10)) * np.sqrt(2 * np.mean(np.sum(diff ** 2, axis=0)))
+    
+    return mcd_value
+
+
+if __name__ == "__main__":
+    ref_file = "../data/vad_example.wav"   # 参考语音文件路径
+    test_file = "../data/vad_example.wav" # 测试语音文件路径
+    
+    ref_wav, ref_sr = sf.read(ref_file)
+    test_wav, test_sr = sf.read(test_file)
+    assert ref_sr == test_sr == 16000, "采样率必须为16000Hz"
+    assert len(ref_wav) == len(test_wav), "音频长度必须相同"
+
+    mcd_value = mcd(ref_wav, test_wav)
+    print(f"梅尔倒谱距离: {mcd_value:.2f}")
+
+    lsd_value = lsd(ref_wav, test_wav)
+    print(f"对数谱距离: {lsd_value:.2f}")
+
+    sd_value = sd(ref_wav, test_wav)
+    print(f"频谱距离: {sd_value:.2f}")
+    

neverlib/metrics/test_pesq.py

@@ -0,0 +1,35 @@
+'''
+Author: 凌逆战 | Never
+Date: 2025-08-05 23:37:31
+Description: 
+
+PESQ 包含 3 种类型的值：NB PESQ MOS、NB MOS LQO、WB MOS LQO。此包仅返回NB PESQ MOS代表 的Raw MOS分数narrowband handset listening。
+'''
+import pesq
+import pypesq
+import librosa
+import os
+import numpy as np
+
+fs = 16000
+clean = librosa.load("../data/000_short.wav", sr=fs)[0]
+enhance = librosa.load("../data/000_short_enhance.wav", sr=fs)[0]
+
+print(pesq.pesq(fs, clean, enhance, 'wb'))  # 3.5920536518096924
+print(pypesq.pesq(clean, enhance, fs=fs))  # 3.817176103591919
+# os.system("./pesq_c/PESQ +16000 ../data/000_short.wav ../data/000_short_enhance.wav")   # WB PESQ_MOS = 3.518
+# os.system("./pesq_c/PESQ +8000 ../data/000_short.wav ../data/000_short_enhance.wav")   # NB PESQ_MOS = 3.477
+
+
+def pesq2mos(pesq):
+    """ 将PESQ值[-0.5, 4.5]映射到MOS-LQO得分[1, 4.5]上，映射函数来源于：P.862.1 """
+    return 0.999 + (4.999 - 0.999) / (1 + np.exp(-1.4945 * pesq + 4.6607))
+
+
+def mos2pesq(mos):
+    """ 将MOS-LQO得分[1, 4.5]映射到PESQ值[-0.5, 4.5]上，映射函数来源于：P.862.1"""
+    inlog = (4.999 - mos) / (mos - 0.999)
+    return (4.6607 - np.log(inlog)) / 1.4945
+
+
+# print(mos2pesq(3.518))

neverlib/metrics/time.py

@@ -0,0 +1,68 @@
+'''
+Author: 凌逆战 | Never
+Date: 2025-08-05 16:44:41
+Description: 
+'''
+"""
+音频数据分析基础工具模块
+Basic Utilities for Audio Data Analysis
+
+提供音频分析的基础工具函数
+"""
+
+import numpy as np
+import librosa
+
+
+def peak_amplitude(wav):
+    """计算峰值幅度
+
+    Args:
+        wav: 音频信号 (*, ch)
+
+    Returns:
+        峰值幅度 (dB)
+    """
+    peak_amp = np.max(np.abs(wav))
+    return peak_amp
+
+
+def rms_amplitude(wav):
+    """计算RMS幅度
+
+    Args:
+        wav: 音频信号 (*, ch)
+
+    Returns:
+        RMS幅度
+    """
+    return np.sqrt(np.mean(np.square(wav)))
+
+
+def mean_rms_amplitude(wav, frame_length=512, hop_length=256):
+    """计算分帧平均RMS幅度
+
+    Args:
+        wav: 音频信号 (*, ch)
+        frame_length: 帧长度
+        hop_length: 跳跃长度
+
+    Returns:
+        平均RMS幅度
+    """
+    # 分帧
+    frame = librosa.util.frame(wav.flatten(), frame_length=frame_length, hop_length=hop_length)
+    rms_amp = np.sqrt(np.mean(np.square(frame), axis=0))
+    return np.mean(rms_amp)
+
+
+def dc_offset(wav):
+    """计算直流分量
+
+    Args:
+        wav: 音频信号 (*, ch)
+
+    Returns:
+        直流分量
+    """
+    return np.mean(wav)

neverlib/tests/test_vad.py

@@ -0,0 +1,21 @@
+'''
+Author: 凌逆战 | Never
+Date: 2025-08-05 17:29:43
+Description: 
+'''
+import os
+import sys
+sys.path.append("../")
+from vad.utils import vad2nad
+
+
+def test_vad2nad():
+    """测试vad2nad函数"""
+    vad = [{'start': 100, 'end': 1000}, {'start': 2000, 'end': 3000}]
+    total_length = 4000
+    nad = vad2nad(vad, total_length)
+    print(nad)
+
+
+if __name__ == "__main__":
+    test_vad2nad()

neverlib/utils/audio_split.py

@@ -14,7 +14,7 @@ from pydub import AudioSegment
 
 
 def audio_split_ffmpeg(source_path, target_path, sr, channel_num, duration, endwith="*.pcm"):
-    """ 切割音频切不准，会留点尾巴0.016s
+    """ 切割音频切不准, 会留点尾巴0.016s
     使用ffmpeg分割音频, 分割为短音频(单位:秒), 似乎无法非常准确的分割到指定长度
     :param source_path: 源音频路径
     :param target_path: 目标音频路径
@@ -94,6 +94,7 @@ def audio_split_np(source_path, target_path, sr, channel_num, duration, endwith=
 
         # 注意读取时使用正确的dtype(例如int16表示16位PCM)
         pcm_data = np.fromfile(wav_path, dtype=np.int16)
+        pcm_data = pcm_data[:(len(pcm_data) // channel_num) * channel_num]
         pcm_data = pcm_data.reshape(-1, channel_num)
 
         # 计算分割的数量

neverlib/utils/message.py

@@ -57,7 +57,7 @@ def send_QQEmail_with_images(title, content, from_name, from_email, from_passwor
     :param from_email: 发件人邮箱
     :param from_password: 发件人邮箱SMTP授权码
     :param to_email: 收件人邮箱
-    :param image_paths: 图片文件路径列表，应为PNG格式
+    :param image_paths: 图片文件路径列表, 应为PNG格式
     """
     # 设置邮箱的域名
     HOST = "smtp.qq.com"
@@ -87,10 +87,10 @@ def send_QQEmail_with_images(title, content, from_name, from_email, from_passwor
             # 使用 MIMEImage 添加图片
             image_part = MIMEImage(img_data)
 
-            # 设置Content-ID，以便在正文中引用图片
+            # 设置Content-ID, 以便在正文中引用图片
             image_part.add_header('Content-ID', cid)
 
-            # 设置为 inline 显示，避免附件处理
+            # 设置为 inline 显示, 避免附件处理
             image_part.add_header('Content-Disposition', 'inline', filename=os.path.basename(image_path))
 
             # 添加图片到邮件
@@ -115,7 +115,7 @@ def send_QQEmail_with_images(title, content, from_name, from_email, from_passwor
 
 
 if __name__ == "__main__":
-    send_QQEmail("实验跑完", "实验跑完了，快去看看吧！",
+    send_QQEmail("实验跑完", "实验跑完了, 快去看看吧！",
                  from_email="1786088386@qq.com", from_password="xxxx",
                  to_email="1786088386@qq.com")
     pass

neverlib/utils/utils.py

@@ -12,6 +12,7 @@ from tqdm import tqdm
 from datetime import datetime
 import soundfile as sf
 import numpy as np
+EPS = np.finfo(float).eps
 
 
 def get_path_list(source_path, end="*.wav", shuffle=False):
@@ -20,7 +21,8 @@ def get_path_list(source_path, end="*.wav", shuffle=False):
         # 实现列表特殊字符的过滤或筛选,返回符合匹配“.wav”字符列表
         for filename in fnmatch.filter(filenames, end):
             wav_list.append(os.path.join(root, filename))
-    print(source_path, len(wav_list))
+    if os.environ.get("LOCAL_RANK", "0") == "0":
+        print(source_path, len(wav_list))
     if shuffle:
         random.shuffle(wav_list)
     return wav_list
@@ -49,10 +51,10 @@ def rename_files_and_folders(directory, replace='_-', replacement='_'):
 def get_file_time(file_path):
     # 获取最后修改时间
     mod_time = os.path.getmtime(file_path)
-    # 转为data_time格式：年-月-日-时-分-秒
+    # 转为data_time格式: 年-月-日-时-分-秒
     datetime_dt = datetime.fromtimestamp(mod_time)
 
-    # 如果时间早于2024-09-04 02:00:00，则删除
+    # 如果时间早于2024-09-04 02:00:00, 则删除
     # if datetime_dt < datetime(2024, 9, 4, 2, 0, 0):
     #     print(file_path)
     return datetime_dt
@@ -97,38 +99,38 @@ def TrainValTestSplit(dataset_dir, train_dir, val_dir, test_dir, percentage=[0.8
     :param percentage: 分割百分比
     """
     assert sum(percentage) == 1.0, "百分比总和必须等于1.0"
-    
+
     wav_path_list = sorted(get_path_list(dataset_dir, end="*.wav"))
     random.seed(10086)
     random.shuffle(wav_path_list)  # 打乱列表的顺序
     total_wav_num = len(wav_path_list)
-    
+
     # 计算训练集、验证集和测试集的分割点
     train_split_idx = int(total_wav_num * percentage[0])
     val_split_idx = train_split_idx + int(total_wav_num * percentage[1])
-    
+
     train_path_list = wav_path_list[:train_split_idx]
     val_path_list = wav_path_list[train_split_idx:val_split_idx]
     test_path_list = wav_path_list[val_split_idx:]
-    
+
     for train_wavpath in tqdm(train_path_list, desc="复制训练集音频"):
         target_path = train_wavpath.replace(dataset_dir, train_dir)
         if not os.path.exists(os.path.split(target_path)[0]):
             os.makedirs(os.path.split(target_path)[0])
         shutil.copy(train_wavpath, target_path)
-    
+
     for val_wavpath in tqdm(val_path_list, desc="复制验证集音频"):
         target_path = val_wavpath.replace(dataset_dir, val_dir)
         if not os.path.exists(os.path.split(target_path)[0]):
             os.makedirs(os.path.split(target_path)[0])
         shutil.copy(val_wavpath, target_path)
-    
+
     for test_wavpath in tqdm(test_path_list, desc="复制测试集音频"):
         target_path = test_wavpath.replace(dataset_dir, test_dir)
         if not os.path.exists(os.path.split(target_path)[0]):
             os.makedirs(os.path.split(target_path)[0])
         shutil.copy(test_wavpath, target_path)
-    
+
     print(f"完成! 训练集: {len(train_path_list)}个文件, 验证集: {len(val_path_list)}个文件, 测试集: {len(test_path_list)}个文件")
 
 
@@ -141,15 +143,33 @@ def get_leaf_folders(directory):
     return leaf_folders
 
 
+def del_empty_folders(path):
+    """递归删除空文件夹(先删除子文件夹, 再删除父文件夹)"""
+    if not os.path.isdir(path):
+        return
+
+    # 获取子文件夹
+    subfolders = [os.path.join(path, d) for d in os.listdir(path) if os.path.isdir(os.path.join(path, d))]
+
+    # 递归处理子文件夹
+    for subfolder in subfolders:
+        del_empty_folders(subfolder)
+
+    # 如果文件夹为空，则删除
+    if not os.listdir(path):
+        os.rmdir(path)
+        print(f"删除空文件夹: {path}")
+
+
 def DatasetSubfloderSplit(source_dir, split_dirs, percentage=None):
     """
     将一个数据集按照子文件夹数量分割成train/val/test数据集
     Args:
         source_dir (str): 源数据集目录
-        split_dirs (list): 目标目录列表，如 [train_dir, val_dir] 或 [train_dir, val_dir, test_dir]
-        percentage (list, optional): 分割比例，如 [0.9, 0.1] 或 [0.8, 0.1, 0.1]。默认为 None，此时：
-            - 如果是两路分割，默认为 [0.9, 0.1]
-            - 如果是三路分割，默认为 [0.8, 0.1, 0.1]
+        split_dirs (list): 目标目录列表, 如 [train_dir, val_dir] 或 [train_dir, val_dir, test_dir]
+        percentage (list, optional): 分割比例, 如 [0.9, 0.1] 或 [0.8, 0.1, 0.1]。默认为 None, 此时: 
+            - 如果是两路分割, 默认为 [0.9, 0.1]
+            - 如果是三路分割, 默认为 [0.8, 0.1, 0.1]
     Example:
         # 两路分割示例
         DatasetSplit(
@@ -247,11 +267,11 @@ def save_weight_histogram(model, save_dir, mode=["params", "buffers"], ignore_na
     Args:
         model: PyTorch模型
         save_dir: 保存路径
-        mode: 保存模式，可选值为["params", "buffers"]
+        mode: 保存模式, 可选值为["params", "buffers"]
         bins: 直方图bin数量
     """
     import matplotlib.pyplot as plt
-    # 如果路径存在，则删除
+    # 如果路径存在, 则删除
     if os.path.exists(save_dir):
         shutil.rmtree(save_dir)
 

neverlib/vad/PreProcess.py

@@ -1,7 +1,7 @@
 '''
 Author: 凌逆战 | Never
 Date: 2025-02-13 20:06:07
-LastEditTime: 2025-03-17 16:06:11
+LastEditTime: 2025-08-16 02:07:24
 FilePath: \neverlib\vad\PreProcess.py
 Description: 
 '''
@@ -9,13 +9,16 @@ Description:
 # Author:凌逆战 | Never
 # Date: 2024/9/14
 """
-通过一些预处理方法，来提高VAD的准确率
+通过一些预处理方法, 来提高VAD的准确率
 """
 import numpy as np
 import noisereduce as nr
 
 
 def pre_emphasis(audio_data, alpha=0.97):
+    """
+    预加重
+    """
     # y(n)=x(n)−α⋅x(n−1)
     emphasized_audio = np.append(audio_data[0], audio_data[1:] - alpha * audio_data[:-1])
     return emphasized_audio
@@ -45,7 +48,7 @@ def NS(wav, sr=16000, stationary=True, prop_decrease=1.):
 def NS_test():
     import soundfile as sf
     sr = 16000
-    wav_path = "../../wav_data/000_short.wav"
+    wav_path = "../../data/vad_example.wav"
     wav, wav_sr = sf.read(wav_path, always_2d=False, dtype="float32")
     wav_NS = NS(wav, sr=sr, stationary=True, prop_decrease=0.6)
     sf.write("../../wav_data/000_short_NS.wav", wav_NS, samplerate=sr)