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

neverlib/audio_aug/clip_aug.py

@@ -0,0 +1,41 @@
+'''
+Author: 凌逆战 | Never
+Date: 2025-07-29 17:06:28
+Description: 
+'''
+import sys
+sys.path.append("..")
+import librosa
+import numpy as np
+import soundfile as sf
+import random
+from audiomentations import Compose, ClippingDistortion
+
+
+def clipping_aug(wav):
+    """
+    模拟录音设备或音频处理设备的动态范围限制
+    """
+    wav = wav / np.max(np.abs(wav))  # 归一化
+    gain = random.uniform(1.0, 2)   # 增益
+    wav = wav * gain
+    wav = np.clip(wav, -1.0, 1.0)
+
+    return wav
+
+
+wav_path = "/data/never/Desktop/kws_train/QA/wav_data/TIMIT.wav"
+wav, wav_sr = sf.read(wav_path, always_2d=True)
+wav = wav.T
+print(wav.shape)
+
+# 应用削波增强
+# 我们让削波阈值在音频振幅的50%到75%之间随机选择
+# 这意味着信号中最响亮的25%到50%的部分将被削平
+y_clipped = clipping_aug(wav, wav_sr, min_percentile=50, max_percentile=75)
+
+# 保存增强后的音频
+output_path = './augmented_clipped.wav'
+sf.write(output_path, y_clipped.T, wav_sr)
+
+print(f"削波增强完成！增强后的音频已保存至: {output_path}")

neverlib/audio_aug/coder_aug.py

@@ -0,0 +1,209 @@
+'''
+Author: 凌逆战 | Never
+Date: 2025-07-29 16:52:10
+Description: 
+'''
+"""
+语音编码器数据增强
+MP3 (MPEG-1 Audio Layer III)	
+- 主要用途：音乐分发、播客。互联网音频的“元老”和事实标准。	
+- 压缩特性：在中低码率下, 高频部分可能会有“嗖嗖”声或模糊感 (swishing artifacts)。	
+- 数据增强目的：模拟通用网络音频压缩。	
+
+AAC (Advanced Audio Coding)	
+- 主要用途：流媒体、视频文件、现代设备。被认为是 MP3 的继任者。	
+- 压缩特性：在同等码率下, 通常比 MP3 保留更多高频细节, 音质更好。	
+- 数据增强目的：模拟现代流媒体和移动设备上的音频压缩。	
+
+AMR (Adaptive Multi-Rate)
+- 主要用途：语音通话、移动通信。专为语音优化。
+- 压缩特性：严格为语音设计, 会滤除大部分非语音频率（如音乐）, 导致音乐听起来“电话音”效果。
+- 数据增强目的：固定采样率：AMR-NB (窄带) 为 8kHz, AMR-WB (宽带) 为 16kHz。这一点至关重要！
+"""
+import numpy as np
+import soundfile as sf
+from audiomentations import Mp3Compression
+import av
+import random
+
+# mp3编解码数据增强
+
+
+def mp3_aug(wav, sr):
+    # return Mp3Compression(min_bitrate=64, max_bitrate=192, p=1.0)(samples, sample_rate)
+    return sf.write('audio.mp3', wav, sr, format='MP3', bitrate='192k')
+
+
+def vorbis_aug(wav, sr):
+    sf.write('audio.ogg', wav, sr, subtype='VORBIS')
+
+
+def flac_aug(wav, sr):
+    sf.write(wav, sr, format='FLAC')
+
+
+def opus_aug_save(wav: np.ndarray, sr: int, output_filepath: str):
+    """
+    对音频进行 Opus 压缩, 并直接保存到文件。
+    使用 PyAV 实现, 比特率是随机的。
+    """
+    # 随机选择一个比特率 (kbps)
+    bitrate_kbps = random.choice([24, 32, 48, 64, 96, 128])
+    output_filepath_with_bitrate = output_filepath.replace('.opus', f'_{bitrate_kbps}k.opus')
+
+    print(f"  -> Saving Opus augmented version to: {output_filepath_with_bitrate} (Bitrate: {bitrate_kbps}k)")
+
+    # PyAV 需要 (n_channels, n_samples) 格式
+    wav_ch_first = wav.T if wav.ndim > 1 else wav.reshape(1, -1)
+    layout = 'stereo' if wav.ndim > 1 else 'mono'
+
+    with av.open(output_filepath_with_bitrate, mode='w') as container:
+        stream = container.add_stream('libopus', rate=sr, layout=layout)
+        stream.bit_rate = bitrate_kbps * 1000
+
+        # 确保数据是 float32
+        if wav.dtype != np.float32:
+            wav = wav.astype(np.float32)
+
+        frame = av.AudioFrame.from_ndarray(wav_ch_first, format='flt')
+        frame.sample_rate = sr
+
+        # 编码并写入文件
+        for packet in stream.encode(frame):
+            container.mux(packet)
+        # Flush aac encoder
+        for packet in stream.encode(None):
+            container.mux(packet)
+
+
+def aac_aug_save(wav: np.ndarray, sr: int, output_filepath: str):
+    """
+    对音频进行 AAC 压缩, 并直接保存到文件。
+    使用 PyAV 实现, 比特率是随机的。
+    """
+    # 随机选择一个比特率 (kbps)
+    bitrate_kbps = random.choice([48, 64, 96, 128, 160, 192])
+    # .m4a 是 AAC 更常用的文件后缀
+    output_filepath_with_bitrate = output_filepath.replace('.aac', f'_{bitrate_kbps}k.m4a')
+
+    print(f"  -> Saving AAC augmented version to: {output_filepath_with_bitrate} (Bitrate: {bitrate_kbps}k)")
+
+    # PyAV 需要 (n_channels, n_samples) 格式
+    wav_ch_first = wav.T if wav.ndim > 1 else wav.reshape(1, -1)
+    layout = 'stereo' if wav.ndim > 1 else 'mono'
+
+    # 注意：format='adts' 是原始 AAC 流, 'mp4' 会创建 .m4a/.mp4 容器
+    with av.open(output_filepath_with_bitrate, mode='w', format='mp4') as container:
+        # 使用高质量的 fdk_aac 编码器
+        stream = container.add_stream('libfdk_aac', rate=sr, layout=layout)
+        stream.bit_rate = bitrate_kbps * 1000
+
+        if wav.dtype != np.float32:
+            wav = wav.astype(np.float32)
+
+        frame = av.AudioFrame.from_ndarray(wav_ch_first, format='flt')
+        frame.sample_rate = sr
+
+        for packet in stream.encode(frame):
+            container.mux(packet)
+        for packet in stream.encode(None):
+            container.mux(packet)
+    print(f"     ... success.")
+
+
+def flac_encode_save(
+    wav: np.ndarray,
+    sr: int,
+    output_filepath: str,
+    compression_level: int = 5,
+    bits_per_sample=None
+):
+    """
+    使用 pyFLAC 将 NumPy 音频数组编码为 FLAC 文件并保存。
+
+    参数:
+    wav (np.ndarray): 输入的音频数据。可以是 float 类型 (范围 -1.0 到 1.0)
+                        或 int16/int32 类型。
+    sr (int): 音频的采样率。
+    output_filepath (str): 输出的 .flac 文件路径。
+    compression_level (int, optional): FLAC 压缩级别, 范围 0 (最快) 到 8 (最高压缩, 最慢)。
+                                       默认为 5, 是一个很好的平衡点。
+    bits_per_sample (int, optional): 每个样本的位数。通常是 16 或 24。
+                                     如果为 None, 函数会根据输入 wav 的 dtype 自动推断。
+                                     默认为 None。
+    """
+
+    # --- 1. 数据类型和位深处理 ---
+    # pyFLAC 的 Encoder 需要 int16 或 int32 格式的 NumPy 数组。
+    # 我们需要根据输入数据进行转换。
+
+    if bits_per_sample is None:
+        # 自动推断位深
+        if wav.dtype == np.int16:
+            bits_per_sample = 16
+        elif wav.dtype == np.int32:
+            bits_per_sample = 32
+        else:
+            # 默认将 float 类型转换为 16-bit
+            bits_per_sample = 16
+
+    # 根据确定的位深, 转换数据
+    if bits_per_sample == 16:
+        if wav.dtype != np.int16:
+            # 将 float [-1, 1] 转换为 int16 [-32768, 32767]
+            print("     ... converting audio to int16 for encoding.")
+            wav_int = (wav * 32767).astype(np.int16)
+        else:
+            wav_int = wav
+    elif bits_per_sample == 24 or bits_per_sample == 32:
+        bits_per_sample = 24  # FLAC 更常用 24-bit
+        if wav.dtype != np.int32:
+            print("     ... converting audio to int32 (for 24-bit FLAC).")
+            # 转换为 24-bit 范围内的 int32
+            wav_int = (wav * 8388607).astype(np.int32)
+        else:
+            wav_int = wav
+    else:
+        raise ValueError(f"Unsupported bits_per_sample: {bits_per_sample}. Must be 16, 24, or 32.")
+
+    # --- 2. 初始化编码器 ---
+    encoder = Encoder(
+        sample_rate=sr,
+        bits_per_sample=bits_per_sample,
+        compression_level=compression_level
+    )
+
+    # --- 3. 处理数据并获取编码后的字节 ---
+    # Encoder.process() 可以分块处理, 但对于中等长度的音频, 一次性处理更简单
+    encoded_bytes = encoder.process(wav_int)
+
+    # --- 4. 将字节写入文件 ---
+    with open(output_filepath, 'wb') as f:
+        f.write(encoded_bytes)
+
+    print(f"     ... success.")
+
+
+# AMR编解码数据增强
+
+
+def amr_nb_aug(samples, sample_rate):
+    # return ApplyCodec(encoder="libamr_nb", p=1.0)(samples, sample_rate)
+    return sf.write('audio.amr', wav, sr, format='AMR', bitrate='192k')
+
+
+def amr_wb_aug(wav, sr):
+    # return ApplyCodec(encoder="libamr_wb", p=1.0)(samples, sample_rate)
+    return sf.write('audio.amr', wav, sr, format='AMR', bitrate='192k')
+
+# Opus 编解码数据增强
+
+
+if __name__ == "__main__":
+    wav_path = "/data/never/Desktop/kws_train/QA/wav_data/TIMIT.wav"
+    wav, sr = sf.read(wav_path, always_2d=True)
+    # mp3_aug(wav, sr)
+    ogg_aug(wav, sr)
+    # amr_nb_aug(wav, sr)
+    # amr_wb_aug(wav, sr)
+    # opus_aug(wav, sr)

neverlib/audio_aug/coder_aug2.py

@@ -0,0 +1,118 @@
+'''
+Author: 凌逆战 | Never
+Date: 2025-07-29 17:57:26
+Description: 
+'''
+import numpy as np
+import librosa
+import soundfile as sf
+import subprocess
+import os
+import random
+import io
+
+
+def check_codec_available(codec):
+    """检查指定的编解码器是否在FFmpeg中可用"""
+    try:
+        result = subprocess.run(['ffmpeg', '-encoders'], capture_output=True, text=True)
+        return codec in result.stdout
+    except:
+        return False
+
+def apply_codec_distortion(wav, sr, codec='libopus', bitrate='24k'):
+    """
+    使用 FFmpeg 对音频应用指定的编解码器和码率, 以模拟有损压缩失真。
+
+    参数:
+    wav (np.ndarray): 输入的音频波形。
+    sr (int): 采样率。
+    codec (str): FFmpeg 支持的编码器名称。
+                 例如: 'aac', 'libopus', 'amr_nb', 'amr_wb', 'mp3'。
+    bitrate (str): 目标码率, FFmpeg 格式。例如: '64k', '24k', '12.2k'。
+
+    返回:
+    np.ndarray: 经过编解码器失真的音频波形。
+    """
+    # 检查编解码器是否可用
+    if not check_codec_available(codec):
+        print(f"编解码器 {codec} 不可用, 跳过处理...")
+        return wav
+    # 根据编解码器确定正确的输出文件扩展名
+    if codec == 'libopus':
+        output_ext = '.opus'
+    elif codec == 'aac':
+        output_ext = '.m4a'  # AAC 通常用 m4a 封装
+    elif codec in ['amr_nb', 'amr_wb']:
+        output_ext = '.amr'
+    else:
+        output_ext = f'.{codec.split("_")[0]}'
+
+    input_filename = f"temp_input_{codec}_{bitrate}.wav"
+    output_filename = f"temp_output_{codec}_{bitrate}{output_ext}"
+
+    try:
+        # 1. 将 NumPy 数组写入临时的输入 WAV 文件
+        sf.write(input_filename, wav, sr)
+
+        # 2. 构建 FFmpeg 命令
+        command = ['ffmpeg', '-y', '-i', input_filename, '-c:a', codec, '-b:a', bitrate]
+
+        # 3. 为 AMR 编解码器添加重采样参数
+        if codec in ['amr_nb', 'amr_wb']:
+            command.extend(['-ar', '8000'])  # AMR-NB 需要 8kHz 采样率
+        
+        # 4. 为 AAC 指定输出格式 (移除 -f adts, 使用 MP4 容器)
+        # if codec == 'aac':
+        #     command.extend(['-f', 'adts'])
+
+        command.append(output_filename)
+
+        # 执行命令, 并隐藏输出
+        subprocess.run(command, check=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+
+        # 4. 将编码后的文件转换回 WAV 格式以便读取
+        wav_output = f"temp_final_{codec}_{bitrate}.wav"
+        subprocess.run(['ffmpeg', '-y', '-i', output_filename, wav_output], 
+                      check=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+        
+        # 5. 从 WAV 文件读回失真的音频
+        samples = sf.read(wav_output)[0]
+
+        return samples
+
+    except Exception as e:
+        print(f"FFmpeg 处理失败: {e}")
+        # 如果失败, 返回原始音频
+        return wav
+    finally:
+        # 6. 清理临时文件
+        for temp_file in [input_filename, output_filename, f"temp_final_{codec}_{bitrate}.wav"]:
+            if os.path.exists(temp_file):
+                os.remove(temp_file)
+
+
+# --- 使用示例 ---
+wav_path = "/data/never/Desktop/kws_train/QA/wav_data/TIMIT.wav"
+wav, wav_sr = sf.read(wav_path, always_2d=True)
+
+# 1. 模拟 Opus 编解码器（常用于VoIP, WebRTC）
+print("应用 Opus 编解码器失真...")
+opus_wav = apply_codec_distortion(wav, wav_sr, codec='libopus', bitrate='24k')
+sf.write('augmented_opus.wav', opus_wav, wav_sr)
+
+# 2. 模拟 AAC 编解码器（常用于流媒体, Apple设备）
+print("应用 AAC 编解码器失真...")
+aac_wav = apply_codec_distortion(wav, wav_sr, codec='aac', bitrate='64k')
+sf.write('augmented_aac.wav', aac_wav, wav_sr)
+
+# 3. 模拟 AMR-NB 编解码器（常用于传统移动通信）
+# AMR-NB 的码率是固定的几个值之一
+amr_bitrates = ['4.75k', '5.15k', '5.9k', '6.7k', '7.4k', '7.95k', '10.2k', '12.2k']
+chosen_amr_bitrate = random.choice(amr_bitrates)
+print(f"应用 AMR-NB @ {chosen_amr_bitrate} 编解码器失真...")
+amr_wav = apply_codec_distortion(wav, wav_sr, codec='amr_nb', bitrate=chosen_amr_bitrate)
+# 注意：AMR通常是8kHz采样, librosa加载时会自动重采样, 这里我们保持原始sr
+sf.write('augmented_amr.wav', amr_wav, wav_sr)
+
+print("所有编解码器增强完成！")

neverlib/audio_aug/loss_packet_aug.py

@@ -0,0 +1,103 @@
+'''
+Author: 凌逆战 | Never
+Date: 2025-07-29 16:28:23
+Description: 丢包数据增强
+“置零” vs “缺失”：两种不同的模拟思路
+结论：对于音质修复, 强烈推荐使用“置零”法, 而不是“删除”法。
+
+理由如下：
+
+- 保持时序对齐 (Temporal Alignment): 在音质修复任务中, 模型需要一个一一对应的关系。输入 damaged_audio 的第 t 秒, 应该对应输出 repaired_audio 的第 t 秒, 也对应原始 original_audio 的第 t 秒。
+   如果使用“删除”法, 输入音频变短, 这种对齐关系就被破坏了, 模型无法学习 (损坏的t时刻) -> (修复的t时刻) 的映射。
+- 简化模型训练: 输入和输出的长度保持一致, 意味着你可以直接使用标准的模型架构（如 U-Net）, 而不需要处理复杂的可变长度序列问题。
+- 更贴近修复任务的本质: 音质修复, 特别是丢包补偿 (Packet Loss Concealment, PLC), 其任务本质是**“根据上下文, 猜测并填充一段丢失的音频”**。
+
+“置零”法完美地创造了这样一个场景：模型看到了上下文, 也看到了一个明确的“空白”（零区域）, 它的任务就是把这个空白填上。
+“删除”法则改变了问题的性质, 变成了“检测不连续点并试图将其平滑化”, 这与 PLC 的目标不完全一致。
+
+“置零”是在深度学习框架下对“真正丢弃”问题的一种高效、可解的数学建模。 我们牺牲了一点点物理上的真实性, 换来了模型训练的可行性和高效性。
+'''
+import numpy as np
+import random
+import soundfile as sf
+
+
+def simulate_packet_loss_vectorized(
+    wav: np.ndarray,
+    sample_rate: int,
+    packet_duration_ms: int = 10,
+    loss_rate: float = 0.05,
+    burst_prob: float = 0.2
+) -> np.ndarray:
+    """
+    模拟带有突发性的网络丢包（向量化版本）。
+    使用 NumPy 的向量化操作以获得极高的性能, 避免在 Python 中使用 for 循环。
+
+    参数:
+    - wav: 原始音频波形 (NumPy 数组)。
+    - sample_rate: 采样率。
+    - packet_duration_ms: 每个数据包的时长（毫秒）。
+        packet_duration_ms_list= np.arange(10, 60, 5)   # 包时长一般为10-60ms, 5ms间隔
+        packet_duration_ms = random.choice(packet_duration_ms_list)
+    - loss_rate: 基础丢包率。
+    - burst_prob: 突发丢包概率。
+
+    返回:
+    - 损坏后的音频波形（与原始长度相同）。
+    """
+    # 0. 复制数组, 避免修改原始输入
+    damaged_wav = wav.copy()
+
+    # 1. 计算数据包参数
+    packet_size = int(packet_duration_ms * sample_rate / 1000)
+    if packet_size == 0:
+        return damaged_wav
+
+    num_samples = len(damaged_wav)
+    num_packets = num_samples // packet_size
+
+    # 2. 一次性生成所有包的随机数, 用于决定是否丢包
+    rand_nums = np.random.rand(num_packets)
+
+    # 3. 生成一个表示“是否丢失”的布尔掩码 (loss_mask)
+    # 初始状态下, 所有包都根据基础丢包率决定是否丢失
+    loss_mask = rand_nums < loss_rate
+
+    # 4. 模拟突发丢包 (Burst Loss)
+    # 找到所有根据基础概率可能丢失的包 (potential_burst_starters)
+    # 对于这些包的下一个包, 以更高的 burst_prob 来决定是否丢失
+    # 我们通过对 loss_mask 进行移位和逻辑运算来高效实现
+    # np.roll(loss_mask, 1) 将掩码向右移动一位, 模拟“前一个包”
+    # 第一个包没有前一个包, 所以将其状态设为 False
+    prev_lost_mask = np.roll(loss_mask, 1)
+    prev_lost_mask[0] = False
+
+    # 现在, 如果一个包的前一个包丢失了 (prev_lost_mask is True),
+    # 那么它有 burst_prob 的概率丢失
+    burst_loss_candidates = rand_nums < burst_prob
+
+    # 更新 loss_mask: 如果一个包的前一个丢了, 并且它也满足突发条件, 那么它就丢失
+    loss_mask = np.logical_or(loss_mask, np.logical_and(prev_lost_mask, burst_loss_candidates))
+
+    # 5. 将布尔掩码扩展到整个样本维度
+    # np.repeat 会将每个包的丢失状态 (True/False) 复制 packet_size 次
+    # 例如 [False, True] -> [F,F,F, T,T,T] (假设 packet_size=3)
+    samples_mask = np.repeat(loss_mask, packet_size)
+
+    # 6. 一次性将所有被标记为丢失的样本置零
+    # 这是另一个核心向量化操作
+    # 我们只操作 num_packets * packet_size 长度的区域, 忽略末尾不足一个包的部分
+    valid_length = num_packets * packet_size
+    damaged_wav[:valid_length][samples_mask] = 0
+
+    return damaged_wav
+
+
+# 生成一个白噪声
+white_noise = np.random.randn(100000).astype(np.float32)
+
+# 生成一个损坏的音频
+damaged_audio = simulate_packet_loss_vectorized(white_noise, 16000, loss_rate=0.1, burst_prob=0.5)
+
+# 保存音频
+sf.write("damaged_audio.wav", damaged_audio, 16000)

neverlib/audio_aug/quant_aug.py

@@ -0,0 +1,78 @@
+'''
+Author: 凌逆战 | Never
+Date: 2025-03-26 22:13:21
+Description: 
+'''
+import os
+import sys
+import numpy as np
+import soundfile as sf
+import librosa
+
+print(librosa.__version__)
+
+
+def apply_uniform_quantization(wav, bit_depth=8):
+    """
+    对音频应用均匀量化, 模拟较低位深度的效果。
+
+    参数:
+    wav (np.ndarray): 输入的音频波形, 值应在 [-1.0, 1.0] 范围内。
+    bit_depth (int): 目标模拟的位深度。
+
+    返回:
+    np.ndarray: 量化后的音频波形。
+    """
+    # 计算量化级别数
+    num_levels = 2 ** bit_depth
+
+    # 1. 将 [-1, 1] 映射到 [0, num_levels - 1]
+    # 我们先将 wav 移动到 [0, 2] 范围, 然后缩放
+    scaled_wav = (wav + 1.0) / 2.0 * (num_levels - 1)
+
+    # 2. 四舍五入到最近的整数级别
+    quantized_levels = np.round(scaled_wav)
+
+    # 3. 将整数级别映射回 [-1, 1]
+    quantized_wav = (quantized_levels / (num_levels - 1) * 2.0) - 1.0
+
+    return quantized_wav.astype(np.float32)
+
+
+def apply_mulaw_quantization(wav, bit_depth=8):
+    """
+    【最终正确版】使用 mu_compress 和 mu_expand 模拟 μ-law 量化失真。
+
+    参数:
+    wav (np.ndarray): 输入音频。
+    bit_depth (int): 目标模拟的位深度。
+    """
+    # mu 的值决定了量化级别的数量 (mu + 1)
+    mu = 2**bit_depth - 1
+
+    # 1. 压缩音频并进行量化 (这是信息丢失的关键步骤)
+    # quantize=True 确保了模拟位深度降低的效果
+    compressed_wav = librosa.mu_compress(wav, mu=mu, quantize=True)
+
+    # 2. 扩展信号 (这是解码步骤)
+    # 这个过程无法恢复在量化中丢失的信息
+    expanded_wav = librosa.mu_expand(compressed_wav, mu=mu)
+
+    return expanded_wav
+
+
+# --- 使用示例 ---
+wav_path = "/data/never/Desktop/kws_train/QA/wav_data/TIMIT.wav"
+wav, wav_sr = sf.read(wav_path, always_2d=True)
+
+# 模拟一个 8-bit 的老式数字音频设备
+y_quantized_8bit = apply_uniform_quantization(wav, bit_depth=8)
+sf.write('augmented_quantized_8bit.wav', y_quantized_8bit, wav_sr)
+
+# 模拟一个更差的 4-bit 设备
+y_quantized_4bit = apply_uniform_quantization(wav, bit_depth=4)
+sf.write('augmented_quantized_4bit.wav', y_quantized_4bit, wav_sr)
+
+
+y_q = apply_mulaw_quantization(wav, bit_depth=8)
+sf.write('augmented_mulaw_8bit.wav', y_q, wav_sr)

neverlib/data_analyze/__init__.py

@@ -0,0 +1,14 @@
+'''
+Author: 凌逆战 | Never
+Date: 2025-08-06 00:56:39
+Description: 
+'''
+"""
+音频数据分析模块
+Audio Data Analysis Module
+
+提供完整的音频数据分析功能, 包括特征提取、质量评估、统计分析和可视化等。
+"""
+
+# 基础工具
+from neverlib.dataAnalyze.temporal_features import dB, peak_amplitude, rms_amplitude

neverlib/filter/auto_eq/__init__.py

@@ -0,0 +1,36 @@
+'''
+Author: 凌逆战 | Never
+Date: 2025-08-19 21:26:54
+Description: 
+AudoEQ - 自动EQ补偿模块
+Author: 凌逆战 | Never
+
+该模块提供多种自动EQ补偿方法:
+- 频谱直接补偿 (auto_eq_spectral_direct)
+- 差分进化优化 (auto_eq_de)  
+- 遗传算法基础版 (auto_eq_ga_basic)
+- 遗传算法高级版 (auto_eq_ga_advanced)
+'''
+
+# 频谱直接补偿方法
+from .freq_eq import get_freq_eq
+
+# 差分进化优化方法
+# from .de_eq import (
+#     get_filter_function,
+#     match_frequency_response,
+#     plot_spectra_comparison
+# )
+
+# 遗传算法基础版
+# from .ga_eq_basic import (
+#     individual_creator,
+#     get_magnitude_spectrum_db,
+#     get_single_filter_freq_response_db_from_coeffs,
+#     get_combined_eq_response_db,
+#     evaluate_individual,
+#     custom_mutate,
+# )
+
+# 遗传算法高级版
+# from .ga_eq_advanced import EQOptimizer