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

neverlib/.history/metrics/snr_20250827234030.py

@@ -0,0 +1,186 @@
+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/utils/audio_split_20250805234209.py

@@ -0,0 +1,268 @@
+'''
+Author: 凌逆战 | Never
+Date: 2025-04-10 18:07:03
+Description: 音频切割
+'''
+import os
+import random
+import subprocess
+from tqdm import tqdm
+import soundfile as sf
+import numpy as np
+from .utils import get_path_list
+from pydub import AudioSegment
+
+
+def audio_split_ffmpeg(source_path, target_path, sr, channel_num, duration, endwith="*.pcm"):
+    """ 切割音频切不准, 会留点尾巴0.016s
+    使用ffmpeg分割音频, 分割为短音频(单位:秒), 似乎无法非常准确的分割到指定长度
+    :param source_path: 源音频路径
+    :param target_path: 目标音频路径
+    :param sr: 源音频采样率
+    :param channel_num: 源音频声道数
+    :param duration: 分割为时长(短音频)(单位:秒)
+    :param endwith: 音频格式(支持pcm和wav)
+    """
+    wav_path_list = get_path_list(source_path, end=endwith)
+    print("待分割的音频数: ", len(wav_path_list))
+    for wav_path in wav_path_list:
+        wav_folder = wav_path[:-4].replace(source_path, target_path)
+        os.makedirs(wav_folder, exist_ok=True)
+
+        if endwith == "*.pcm":
+            # 将pcm文件切割成30s的语音, 有括号会报错
+            # ffmpeg -f s16le -ar 16000 -ac 6 -i ./NO.1_A3035_2.pcm -f segment -segment_time 30 -c copy NO.1_A3035_2/%03d.wav
+            command = ["ffmpeg", "-f", "s16le", "-ar", f"{sr}", "-ac", str(channel_num),
+                       "-i", wav_path, "-f", "segment", "-segment_time",
+                       f"{duration}", "-c", "copy", f"{wav_folder}/%03d.wav"]
+            subprocess.run(command, check=True)
+        elif endwith == "*.wav":
+            # ffmpeg -i ./NO.1_A3035_2.wav -f segment -segment_time 30 -c copy NO.1_A3035_2/%03d.wav
+            command = ["ffmpeg", "-i", wav_path, "-f", "segment", "-segment_time",
+                       f"{duration}", "-c", "copy", f"{wav_folder}/%03d.wav"]
+            subprocess.run(command, check=True)
+        else:
+            assert False, "不支持的音频格式"
+    print("分割完毕: done!")
+
+
+def audio_split_sox(source_path, target_path, duration, endwith="*.wav"):
+    """
+    使用sox分割音频, 分割为短音频(单位:秒), 可以非常准确的分割到指定长度
+    :param source_path: 源音频路径
+    :param target_path: 目标音频路径
+    :param duration: 分割为时长(短音频)(单位:秒)
+    :param endwith: 音频格式(只支持wav)
+    """
+    wav_path_list = get_path_list(source_path, end=endwith)
+
+    for wav_path in wav_path_list:
+        wav_folder = wav_path[:-4].replace(source_path, target_path)
+        os.makedirs(wav_folder, exist_ok=True)
+
+        output_pattern = f"{wav_folder}/%.wav"
+
+        if endwith == "*.wav":
+            # 对 WAV 文件直接进行分割
+            os.system(f"sox {wav_path} {output_pattern} trim 0 {str(duration)} : newfile : restart")
+        else:
+            assert False, "不支持的音频格式"
+
+    print("分割完毕: done!")
+
+
+def audio_split_np(source_path, target_path, sr, channel_num, duration, endwith="*.pcm"):
+    """
+    使用numpy读取pcm文件并切割保存为wav文件, 保持通道数一致, 保存不足30秒的最后一段音频
+    :param source_path: 源音频路径
+    :param target_path: 目标音频路径
+    :param sr: 采样率
+    :param channel_num: 声道数
+    :param duration: 分割的时长 (秒)
+    :param endwith: 音频格式 (支持 pcm)
+    """
+    assert endwith == "*.pcm", "只支持pcm格式的音频"
+    wav_path_list = get_path_list(source_path, end=endwith)  # 获取音频文件列表
+    print("待分割的音频数: ", len(wav_path_list))
+
+    segment_length_samples = duration * sr  # 每个切片音频的采样点数
+
+    for wav_path in wav_path_list:
+        print("正在分割: ", wav_path)
+        wav_folder = wav_path[:-4].replace(source_path, target_path)
+        os.makedirs(wav_folder, exist_ok=True)
+
+        # 注意读取时使用正确的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)
+
+        # 计算分割的数量
+        num_segments = len(pcm_data) // segment_length_samples
+
+        # 切割并保存每段音频
+        for i in tqdm(range(num_segments)):
+            start_idx = i * segment_length_samples
+            end_idx = (i + 1) * segment_length_samples
+            segment = pcm_data[start_idx:end_idx]
+            segment_filename = os.path.join(wav_folder, f"{i + 1:03d}.wav")   # 保存为wav文件
+            sf.write(segment_filename, segment, sr, subtype='PCM_16')
+
+        # 如果剩余部分少于30秒, 保存最后一段不足30秒的音频
+        remaining_samples = len(pcm_data) % segment_length_samples
+        if remaining_samples > 0:
+            segment = pcm_data[-remaining_samples:]
+            # 保存剩余部分
+            remaining_filename = os.path.join(wav_folder, f"{num_segments + 1:03d}.wav")
+            sf.write(remaining_filename, segment, sr, subtype='PCM_16')
+
+    print("分割完毕: done!")
+
+
+def audio_split_pydub(source_path, target_path, sr, channel_num, duration, endwith="*.pcm", sample_width=2):
+    """
+    使用pydub分割音频, 进行精确的分割
+    :param source_path: 源音频路径
+    :param target_path: 目标音频路径
+    :param sr: 源音频采样率
+    :param channel_num: 源音频声道数
+    :param duration: 分割为时长(短音频)(单位:秒), 必须是1s的整数倍
+    :param endwith: 音频格式(支持pcm和wav)
+    :param sample_width: 音频的样本宽度(字节数), 默认为2, 表示16位音频
+    """
+    assert duration % 1 == 0, "duration必须是1s的整数倍"
+    wav_path_list = get_path_list(source_path, end=endwith)  # 获取音频文件列表
+    print("待分割的音频数: ", len(wav_path_list))
+
+    for wav_path in wav_path_list:
+        print("正在分割: ", wav_path)
+        wav_folder = wav_path[:-4].replace(source_path, target_path)  # 设置目标文件夹
+        os.makedirs(wav_folder, exist_ok=True)
+
+        # 使用pydub加载音频
+        if endwith == "*.pcm":
+            # 读取pcm文件, 指定采样率、声道数和样本宽度
+            audio = AudioSegment.from_file(wav_path, format="raw", channels=channel_num, frame_rate=sr, sample_width=sample_width)
+        elif endwith == "*.wav":
+            # 读取wav文件
+            audio = AudioSegment.from_wav(wav_path)
+        else:
+            assert False, "不支持的音频格式"
+
+        # 计算每段的时长(以毫秒为单位)
+        segment_length = duration * 1000  # 转换为毫秒
+
+        # 切割音频并保存为多个文件
+        segment_number = 1
+        for i in tqdm(range(0, len(audio), segment_length)):
+            segment = audio[i:i + segment_length]
+            segment_filename = os.path.join(wav_folder, f"{segment_number:03d}.wav")
+            segment.export(segment_filename, format="wav")
+            segment_number += 1
+
+    print("分割完毕: done!")
+
+
+def audio_split_random(source_dir, target_dir, min_duration=3, max_duration=10, sr=16000):
+    """
+    将音频切割成 3 到 10 秒的多个片段并保存。
+    参数:
+    - input_audio_path: 输入音频文件路径
+    - output_dir: 输出音频文件夹路径
+    - min_duration: 最短切割片段长度 (秒), 默认3秒
+    - max_duration: 最长切割片段长度 (秒), 默认10秒
+    - sample_rate: 采样率, 默认16000
+    """
+    wav_path_list = get_path_list(source_dir, "*.wav")
+    for wav_path in wav_path_list:
+        output_dir = wav_path[:-4].replace(source_dir, target_dir)
+        os.makedirs(output_dir, exist_ok=True)
+
+        wav, wav_sr = sf.read(wav_path, always_2d=True)
+        assert wav_sr == sr, f"音频采样率不匹配: {wav_sr} != {sr}"
+        count = 0
+        while len(wav) > max_duration * sr:
+            segment_len = random.randint(min_duration * sr, max_duration * sr)
+            segment = wav[0: segment_len]
+            wav = wav[segment_len:]
+            count += 1
+            sf.write(os.path.join(output_dir, f"{count}.wav"), segment, sr)
+        sf.write(os.path.join(output_dir, f"{count + 1}.wav"), wav, sr)
+
+
+def audio_split_VADfunasr(source_dir, target_dir, sr=16000):
+    """
+    使用funasr的vad模型将音频中的语音分割成短句
+    """
+    from filter import HPFilter
+    from audio_aug import volume_norm
+    from funasr import AutoModel
+    model = AutoModel(model="fsmn-vad", model_revision="v2.0.4")
+
+    wav_path_list = get_path_list(source_dir, "*.wav")
+    for wav_path in wav_path_list:
+        wav_folder = wav_path[:-4].replace(source_dir, target_dir)
+        os.makedirs(wav_folder, exist_ok=True)
+
+        wav_orig, wav_sr = sf.read(wav_path, always_2d=True)
+        assert wav_sr == sr, f"音频采样率为{wav_sr}, 期望为{sr}"
+
+        wav = HPFilter(wav_orig[:, 0], sr=sr, order=6, cutoff=100)
+        wav = volume_norm(wav)
+
+        res_list = model.generate(input=wav)
+
+        for res in res_list:
+            for i, value_item in enumerate(res["value"]):
+                start, end = value_item
+                start, end = int(start * wav_sr / 1000), int(end * wav_sr / 1000)
+
+                # short_wav = wav_orig[start - int(0.5 * sr):end + int(0.5 * sr)]
+                # duration = (end - start) / sr
+                # assert len(short_wav) > sr * 3, f"{end/sr:.2f}-{start/sr:.2f}={duration:.2f}"
+                sf.write(os.path.join(wav_folder, f"{i}.wav"), wav_orig[start:end], sr)
+        # break
+
+
+def audio_split_VADsilero(source_dir, target_dir, sr, threshold=0.4,
+                          min_speech_duration_ms=400, min_silence_duration_ms=400,
+                          window_size_samples=512, speech_pad_ms=500):
+    """
+    使用silero的vad模型将音频中的语音分割成短句
+    source_dir: 音频文件目录
+    target_dir: 分割后的音频文件目录
+    sr: 音频采样率
+    threshold: 阈值
+    min_speech_duration_ms: 语音块的最小持续时间 ms
+    min_silence_duration_ms: 语音块之间的最小静音时间 ms
+    window_size_samples: 512\1024\1536
+    """
+    import torch
+    from filter import HPFilter
+    from audio_aug import volume_norm
+    model, utils = torch.hub.load(repo_or_dir='snakers4/silero-vad', model='silero_vad', force_reload=False, onnx=True)
+    (get_speech_timestamps, save_audio, read_audio, VADIterator, collect_chunks) = utils
+
+    wav_path_list = get_path_list(source_dir, "*.wav")
+    for wav_path in wav_path_list:
+        wav_folder = wav_path[:-4].replace(source_dir, target_dir)
+        os.makedirs(wav_folder, exist_ok=True)
+
+        wav_orig, wav_sr = sf.read(wav_path, always_2d=True)
+        assert wav_sr == sr, f"音频采样率为{wav_sr}, 期望为{sr}"
+
+        wav = HPFilter(wav_orig[:, 0], sr=sr, order=6, cutoff=100)
+        wav = volume_norm(wav)
+
+        speech_timestamps = get_speech_timestamps(wav, model,
+                                                  sampling_rate=sr,
+                                                  threshold=threshold,
+                                                  min_speech_duration_ms=min_speech_duration_ms,  # 语音块的最小持续时间 ms
+                                                  min_silence_duration_ms=min_silence_duration_ms,  # 语音块之间的最小静音时间 ms
+                                                  window_size_samples=window_size_samples,  # 512\1024\1536
+                                                  speech_pad_ms=speech_pad_ms,  # 最后的语音块由两侧的speech_pad_ms填充
+                                                  )
+        for i, timestamp in enumerate(speech_timestamps):
+            wav_vad = wav_orig[timestamp["start"]:timestamp["end"]]
+
+            sf.write(os.path.join(wav_folder, f"{i}.wav"), wav_vad, sr)