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

neverlib/filter/AudoEQ/auto_eq_ga_basic.py

@@ -0,0 +1,380 @@
+import sys
+sys.path.append("..")
+import random
+import numpy as np
+import soundfile as sf
+import scipy.signal as signal
+from scipy.signal import lfilter, freqz
+import matplotlib.pyplot as plt
+from deap import base, creator, tools, algorithms
+from filter import EQFilter
+
+# --- Configuration Parameters ---
+SOURCE_AUDIO_PATH = "../data/white.wav"
+TARGET_AUDIO_PATH = "../data/white_EQ.wav"
+OUTPUT_MATCHED_AUDIO_PATH = "../data/white_matched.wav"
+
+SR = 16000
+NFFT = 1024
+FREQ_NUM = NFFT // 2 + 1
+
+# --- GA Configuration - 需要重点调整这些参数 ---
+MAX_FILTERS = 10       # 尝试增加或减少, 取决于EQ预期复杂度
+POPULATION_SIZE = 200  # 建议增加 (例如 100-200)
+MAX_GENERATIONS = 150  # 建议增加 (例如 100-300, 甚至更多)
+CXPB = 0.7            # 交叉概率
+MUTPB_IND = 0.4       # 个体变异概率, 可以适当增加以增强探索
+MUTPB_GENE = 0.15     # 基因变异概率, 可以适当增加
+
+# 复杂度惩罚因子 - 关键调整参数!
+# 初始可以尝试较小的值, 如果滤波器过多, 再逐渐增大
+COMPLEXITY_PENALTY_FACTOR = 0.01  # 尝试不同的值: 0.001, 0.005, 0.01, 0.05, 0.1 等
+
+# Filter Type Definitions (整数编码)
+FILTER_TYPE_PEAK = 0
+FILTER_TYPE_LOW_SHELF = 1
+FILTER_TYPE_HIGH_SHELF = 2
+AVAILABLE_FILTER_TYPES = [FILTER_TYPE_PEAK, FILTER_TYPE_LOW_SHELF, FILTER_TYPE_HIGH_SHELF]
+
+FILTER_TYPE_MAP_INT_TO_STR = {
+    FILTER_TYPE_PEAK: 'peak',
+    FILTER_TYPE_LOW_SHELF: 'low_shelf',
+    FILTER_TYPE_HIGH_SHELF: 'high_shelf',
+}
+# 创建EQFilter实例
+eq_filter = EQFilter(fs=SR)
+
+FILTER_TYPE_MAP_INT_TO_FUNC = {
+    FILTER_TYPE_PEAK: eq_filter.PeakingFilter,
+    FILTER_TYPE_LOW_SHELF: eq_filter.LowshelfFilter,
+    FILTER_TYPE_HIGH_SHELF: eq_filter.HighshelfFilter,
+}
+
+# Parameter Bounds
+FC_MIN, FC_MAX = 20, SR / 2 - 50
+Q_MIN_PEAK, Q_MAX_PEAK = 0.3, 10.0
+Q_MIN_SHELF, Q_MAX_SHELF = 0.3, 2.0
+DBGAIN_MIN, DBGAIN_MAX = -25.0, 25.0  # 略微扩大增益范围
+
+Q_BOUNDS_PER_TYPE = {
+    FILTER_TYPE_PEAK: (Q_MIN_PEAK, Q_MAX_PEAK),
+    FILTER_TYPE_LOW_SHELF: (Q_MIN_SHELF, Q_MAX_SHELF),
+    FILTER_TYPE_HIGH_SHELF: (Q_MIN_SHELF, Q_MAX_SHELF),
+}
+
+GENES_PER_FILTER_BLOCK = 5
+
+creator.create("FitnessMin", base.Fitness, weights=(-1.0,))
+creator.create("Individual", list, fitness=creator.FitnessMin)
+
+toolbox = base.Toolbox()
+
+
+def generate_active_gene(): return random.randint(0, 1)
+def generate_type_gene(): return random.choice(AVAILABLE_FILTER_TYPES)
+def generate_fc_gene(): return random.uniform(FC_MIN, FC_MAX)
+
+
+def generate_q_gene(filter_type_int):
+    q_min, q_max = Q_BOUNDS_PER_TYPE[filter_type_int]
+    return random.uniform(q_min, q_max)
+
+
+def generate_dbgain_gene(): return random.uniform(DBGAIN_MIN, DBGAIN_MAX)
+
+
+attribute_generators = []
+for i in range(MAX_FILTERS):
+    toolbox.register(f"active_{i}", generate_active_gene)
+    attribute_generators.append(toolbox.__getattribute__(f"active_{i}"))
+    toolbox.register(f"type_{i}", generate_type_gene)
+    attribute_generators.append(toolbox.__getattribute__(f"type_{i}"))
+    toolbox.register(f"fc_{i}", generate_fc_gene)
+    attribute_generators.append(toolbox.__getattribute__(f"fc_{i}"))
+    attribute_generators.append(None)
+    toolbox.register(f"dbgain_{i}", generate_dbgain_gene)
+    attribute_generators.append(toolbox.__getattribute__(f"dbgain_{i}"))
+
+
+def individual_creator():
+    chromosome = []
+    for i in range(MAX_FILTERS):
+        active = generate_active_gene()
+        type_val = generate_type_gene()
+        fc = generate_fc_gene()
+        q = generate_q_gene(type_val)
+        dbgain = generate_dbgain_gene()
+        chromosome.extend([active, type_val, fc, q, dbgain])
+    return creator.Individual(chromosome)
+
+
+toolbox.register("individual", individual_creator)
+toolbox.register("population", tools.initRepeat, list, toolbox.individual)
+
+
+def get_magnitude_spectrum_db(audio, sr, n_fft):
+    # 使用 spectrogram 进行频谱估计, 并对时间帧平均
+    f_spec, t_spec, Sxx_spec = signal.spectrogram(audio, fs=sr, nperseg=n_fft, noverlap=n_fft // 4, scaling='spectrum', mode='magnitude')
+    avg_magnitude_spectrum_spec = np.mean(Sxx_spec, axis=1)
+    db_spectrum = 20 * np.log10(avg_magnitude_spectrum_spec + 1e-12)
+    return f_spec, db_spectrum
+
+
+def get_single_filter_freq_response_db_from_coeffs(filter_params, num_freq_points, fs_proc):
+    # 为每个滤波器创建新的EQFilter实例, 使用正确的采样率
+    eq_filter_instance = EQFilter(fs=fs_proc)
+    filter_type = filter_params['type_int']
+    if filter_type == FILTER_TYPE_PEAK:
+        filter_func = eq_filter_instance.PeakingFilter
+    elif filter_type == FILTER_TYPE_LOW_SHELF:
+        filter_func = eq_filter_instance.LowshelfFilter
+    else:  # HIGH_SHELF
+        filter_func = eq_filter_instance.HighshelfFilter
+
+    b, a = filter_func(fc=filter_params['fc'], Q=filter_params['q'], dBgain=filter_params['dBgain'])
+    w_native, h_native = freqz(b, a, worN=num_freq_points, fs=fs_proc)
+    response_db_native = 20 * np.log10(np.abs(h_native) + 1e-12)
+    return w_native, response_db_native
+
+
+def get_combined_eq_response_db(active_filters_list, num_points_calc, fs_proc, freq_axis_target):
+    num_target_freq_bins = len(freq_axis_target)
+    combined_response_db = np.zeros(num_target_freq_bins)
+    if not active_filters_list:
+        return combined_response_db
+
+    for p_dict in active_filters_list:
+        w_native, individual_response_db_native = get_single_filter_freq_response_db_from_coeffs(
+            p_dict, num_points_calc, fs_proc
+        )
+        individual_response_db_interp = np.interp(
+            freq_axis_target, w_native, individual_response_db_native
+        )
+        combined_response_db += individual_response_db_interp
+    return combined_response_db
+
+
+target_eq_shape_db_global = None
+objective_freq_axis_global = None
+
+
+def evaluate_individual(individual_chromosome):
+    global target_eq_shape_db_global, objective_freq_axis_global
+    if target_eq_shape_db_global is None or objective_freq_axis_global is None:
+        raise ValueError("全局目标频谱未设置!")  # 中文注释
+
+    active_filters_params_list = []
+    num_active_filters = 0
+
+    for i in range(MAX_FILTERS):
+        base_idx = i * GENES_PER_FILTER_BLOCK
+        is_active = individual_chromosome[base_idx]
+
+        if is_active == 1:
+            num_active_filters += 1
+            filter_type_int = individual_chromosome[base_idx + 1]
+            fc_val = individual_chromosome[base_idx + 2]
+            q_val = individual_chromosome[base_idx + 3]
+            dbgain_val = individual_chromosome[base_idx + 4]
+
+            fc_val = np.clip(fc_val, FC_MIN, FC_MAX)
+            q_min_type, q_max_type = Q_BOUNDS_PER_TYPE[filter_type_int]
+            q_val = np.clip(q_val, q_min_type, q_max_type)
+            dbgain_val = np.clip(dbgain_val, DBGAIN_MIN, DBGAIN_MAX)
+
+            active_filters_params_list.append({
+                'type_int': filter_type_int,
+                'fc': fc_val,
+                'q': q_val,
+                'dBgain': dbgain_val,
+                'fs': SR
+            })
+
+    if not active_filters_params_list:
+        achieved_eq_response_db = np.zeros_like(target_eq_shape_db_global)
+    else:
+        achieved_eq_response_db = get_combined_eq_response_db(
+            active_filters_params_list,
+            FREQ_NUM,
+            SR,
+            objective_freq_axis_global
+        )
+
+    error = np.sum((achieved_eq_response_db - target_eq_shape_db_global)**2)
+
+    # 调整复杂度惩罚项的计算方式, 使其与误差的量级更相关
+    # 例如, 如果误差本身就很大, 那么滤波器的数量惩罚可以相对小一些
+    # 或者, 如果目标EQ形状本身就很复杂（变化剧烈）, 那么多用几个滤波器也是合理的
+    # penalty_scale = 1 + np.mean(np.abs(target_eq_shape_db_global)) # 基于目标EQ形状的平均绝对值
+    penalty_scale = np.sum(target_eq_shape_db_global**2) / len(target_eq_shape_db_global) if len(target_eq_shape_db_global) > 0 else 1.0
+    if penalty_scale < 1e-3:
+        penalty_scale = 1.0  # 避免除以过小的值或0
+
+    complexity_cost = COMPLEXITY_PENALTY_FACTOR * num_active_filters * (1 + penalty_scale * 0.1)
+
+    total_cost = error + complexity_cost
+    return (total_cost,)
+
+
+toolbox.register("evaluate", evaluate_individual)
+toolbox.register("mate", tools.cxTwoPoint)
+
+
+def custom_mutate(individual, indpb_gene):
+    for i in range(len(individual)):
+        if random.random() < indpb_gene:
+            block_index = i // GENES_PER_FILTER_BLOCK
+            gene_type_in_block = i % GENES_PER_FILTER_BLOCK
+
+            current_filter_type_gene_idx = block_index * GENES_PER_FILTER_BLOCK + 1
+            current_filter_type = individual[current_filter_type_gene_idx]
+
+            if gene_type_in_block == 0:  # Active gene
+                individual[i] = 1 - individual[i]
+            elif gene_type_in_block == 1:  # Type gene
+                new_type = random.choice([t for t in AVAILABLE_FILTER_TYPES if t != individual[i]])
+                individual[i] = new_type
+                q_gene_idx = block_index * GENES_PER_FILTER_BLOCK + 3
+                individual[q_gene_idx] = generate_q_gene(new_type)  # 根据新类型更新Q
+            elif gene_type_in_block == 2:  # Fc gene
+                individual[i] = generate_fc_gene()
+            elif gene_type_in_block == 3:  # Q gene
+                individual[i] = generate_q_gene(current_filter_type)  # Q依赖于当前块的Type
+            elif gene_type_in_block == 4:  # dBGain gene
+                individual[i] = generate_dbgain_gene()
+    return individual,
+
+
+toolbox.register("mutate", custom_mutate, indpb_gene=MUTPB_GENE)
+toolbox.register("select", tools.selTournament, tournsize=3)  # 锦标赛选择, tournsize可调整
+
+
+def main_ga():
+    global target_eq_shape_db_global, objective_freq_axis_global
+
+    source_audio, sr = sf.read(SOURCE_AUDIO_PATH)
+    target_audio, sr = sf.read(TARGET_AUDIO_PATH)
+    assert sr == SR, "采样率不匹配"
+    assert source_audio.ndim == 1, "源音频必须是单声道"
+
+    source_freq_axis, source_db_spectrum = get_magnitude_spectrum_db(
+        source_audio, SR, NFFT
+    )
+    target_freq_axis, target_db_spectrum = get_magnitude_spectrum_db(
+        target_audio, SR, NFFT
+    )
+    assert np.array_equal(source_freq_axis, target_freq_axis), "源频谱和目标频谱的频率轴不一致"
+
+    target_eq_shape_db_global = target_db_spectrum - source_db_spectrum
+    objective_freq_axis_global = source_freq_axis
+
+    print(f"运行遗传算法 (种群: {POPULATION_SIZE}, 迭代: {MAX_GENERATIONS}, 最大滤波器数: {MAX_FILTERS})...")  # 中文注释
+    population = toolbox.population(n=POPULATION_SIZE)
+    hall_of_fame = tools.HallOfFame(1)  # 只记录最好的一个
+
+    # 设置统计信息
+    stats = tools.Statistics(lambda ind: ind.fitness.values)
+    stats.register("avg", np.mean)
+    stats.register("std", np.std)
+    stats.register("min", np.min)
+    stats.register("max", np.max)
+
+    # 运行GA
+    final_pop, logbook = algorithms.eaSimple(
+        population,
+        toolbox,
+        cxpb=CXPB,
+        mutpb=MUTPB_IND,  # 个体变异概率
+        ngen=MAX_GENERATIONS,
+        stats=stats,
+        halloffame=hall_of_fame,
+        verbose=True  # 打印每代统计信息
+    )
+
+    best_individual_chromosome = hall_of_fame[0]
+    print(f"\n最优个体适应度 (误差+惩罚): {best_individual_chromosome.fitness.values[0]:.4f}")  # 中文注释
+
+    # 解码最优个体
+    optimized_eq_params_list = []
+    num_active_found = 0
+    print("\n--- Decoded Optimal EQ Filter Parameters ---")  # 英文输出标题
+    for i in range(MAX_FILTERS):
+        base_idx = i * GENES_PER_FILTER_BLOCK
+        is_active = best_individual_chromosome[base_idx]
+        if is_active == 1:
+            num_active_found += 1
+            filter_type_int = best_individual_chromosome[base_idx + 1]
+            fc_val = best_individual_chromosome[base_idx + 2]
+            q_val = best_individual_chromosome[base_idx + 3]
+            dbgain_val = best_individual_chromosome[base_idx + 4]
+
+            param_dict = {
+                'type': FILTER_TYPE_MAP_INT_TO_STR[filter_type_int],
+                'fc': round(fc_val, 2),
+                'q': round(q_val, 3),
+                'dBgain': round(dbgain_val, 2),
+                'fs': SR
+            }
+            optimized_eq_params_list.append(param_dict)
+            print(param_dict)  # 打印每个找到的滤波器参数
+
+    if not optimized_eq_params_list:
+        print("Warning: Genetic algorithm did not find any active filters.")
+
+    # 应用EQ并保存 (如果找到了滤波器)
+    if optimized_eq_params_list and OUTPUT_MATCHED_AUDIO_PATH:
+        print(f"\nApplying optimized EQ to source audio and saving to {OUTPUT_MATCHED_AUDIO_PATH}...")
+
+        def apply_eq_to_signal_structural(audio, eq_params_list_decoded, fs):
+            processed_audio = np.copy(audio)
+            eq_filter_instance = EQFilter(fs=fs)
+
+            for p_dict_decoded in eq_params_list_decoded:
+                if p_dict_decoded['type'] == 'peak':
+                    filter_func = eq_filter_instance.PeakingFilter
+                elif p_dict_decoded['type'] == 'low_shelf':
+                    filter_func = eq_filter_instance.LowshelfFilter
+                else:  # high_shelf
+                    filter_func = eq_filter_instance.HighshelfFilter
+
+                b, a = filter_func(fc=p_dict_decoded['fc'], Q=p_dict_decoded['q'], dBgain=p_dict_decoded['dBgain'])
+                processed_audio = lfilter(b, a, processed_audio)
+            return processed_audio
+
+        source_audio_matched = apply_eq_to_signal_structural(source_audio, optimized_eq_params_list, SR)
+        sf.write(OUTPUT_MATCHED_AUDIO_PATH, source_audio_matched, SR)
+
+    # 生成对比图
+    print("Generating comparison plot...")  # 英文输出
+    decoded_active_filters_for_eval = []
+    for p_dict in optimized_eq_params_list:
+        type_str_to_int_map = {v: k for k, v in FILTER_TYPE_MAP_INT_TO_STR.items()}
+        decoded_active_filters_for_eval.append({
+            'type_int': type_str_to_int_map[p_dict['type']],
+            'fc': p_dict['fc'],
+            'q': p_dict['q'],
+            'dBgain': p_dict['dBgain']
+        })
+
+    achieved_eq_response_for_sum_db = get_combined_eq_response_db(
+        decoded_active_filters_for_eval, FREQ_NUM, SR, objective_freq_axis_global
+    )
+    source_plus_achieved_eq_db = source_db_spectrum + achieved_eq_response_for_sum_db
+
+    plt.figure(figsize=(12, 7))
+    plt.semilogx(objective_freq_axis_global, source_db_spectrum, label='Source Audio Spectrum', alpha=0.8, color='deepskyblue')
+    plt.semilogx(objective_freq_axis_global, target_db_spectrum, label='Target Audio Spectrum', alpha=0.8, color='coral')
+    plt.semilogx(objective_freq_axis_global, source_plus_achieved_eq_db, label='Source Spectrum + Matched EQ', alpha=0.8, color='limegreen')
+
+    plt.title(f'EQ Matching Result ({num_active_found} active filters) - {SR}Hz')
+    plt.xlabel('Frequency (Hz)')
+    plt.ylabel('Magnitude (dB)')
+    plt.legend(loc='best')
+    plt.xscale('log')
+    plt.grid(True, ls="--", alpha=0.4)
+    plt.tight_layout()
+    plt.savefig("eq_matching_plot_3curves.png")
+
+
+if __name__ == '__main__':
+    main_ga()

neverlib/filter/AudoEQ/auto_eq_spectral_direct.py

@@ -0,0 +1,75 @@
+'''
+Author: 凌逆战 | Never
+Date: 2025-08-04 21:49:05
+Description: 自动EQ补偿
+'''
+import os
+import numpy as np
+import librosa
+import soundfile as sf
+import pandas
+import matplotlib.pyplot as plt
+
+np.set_printoptions(precision=8)
+np.set_printoptions(suppress=True)  # 打印不使用科学计数法
+
+
+def compute_frequency_eq(reference_audio, target_audio, sample_rate, fft_size, window_size, plot_results=False):
+    freq_bins = np.fft.rfftfreq(fft_size, d=1.0 / sample_rate)   # [0, 31.25, 62.5,.....]
+
+    stft_reference = librosa.stft(reference_audio, n_fft=fft_size, hop_length=window_size // 2, win_length=window_size, window="hann")
+    stft_target = librosa.stft(target_audio, n_fft=fft_size, hop_length=window_size // 2, win_length=window_size, window="hann")
+    magnitude_reference, magnitude_target = np.abs(stft_reference), np.abs(stft_target)  # (F,T)
+    # 求时间平均, 频响曲线 Frequency_Response_curve
+    reference_response = np.mean(magnitude_reference, axis=1)
+    target_response = np.mean(magnitude_target, axis=1)
+
+    reference_response_db = 20 * np.log10(reference_response)  # 取对数幅度谱, 以便更好地可视化
+    target_response_db = 20 * np.log10(target_response)  # 取对数幅度谱, 以便更好地可视化
+
+    eq_curve = target_response_db - reference_response_db  # 补偿曲线 (28208, 1)
+    # print("补偿EQ曲线: ", len(eq_curve), np.array2string(np.power(10, eq_curve / 20), separator=', '))
+
+    if plot_results:
+        plt.figure(figsize=(10, 5))
+        plt.plot(freq_bins, target_response_db, label="Target Response")
+        plt.plot(freq_bins, eq_curve, label="EQ Curve")
+        compensated_response = reference_response_db + eq_curve  # 补偿后的曲线
+        plt.plot(freq_bins, compensated_response, label="Compensated Response")
+        plt.xlabel('Frequency (Hz)')
+        plt.ylabel('Amplitude (dB)')
+        plt.title('Frequency Response Compensation')
+        plt.grid(True)
+        plt.legend()
+        plt.xscale('log')
+        plt.grid(True, ls="--", alpha=0.4)
+        plt.tight_layout()
+        # plt.show()
+        plt.savefig(f"./frequency_eq_fft{window_size}.png")
+
+    # 拿到EQ之后我们对音频进行EQ补偿
+    reference_phase = np.angle(stft_reference)  # (F,T)
+    for freq_idx in range(magnitude_reference.shape[0]):
+        magnitude_reference[freq_idx, :] *= np.power(10, eq_curve[freq_idx] / 20)
+    compensated_spectrum = magnitude_reference * np.exp(1.0j * reference_phase)
+    compensated_audio = librosa.istft(compensated_spectrum, hop_length=window_size // 2, win_length=window_size, n_fft=fft_size, window="hann")
+
+    return eq_curve, compensated_audio
+
+
+if __name__ == "__main__":
+    SAMPLE_RATE = 16000
+    WINDOW_SIZE = FFT_SIZE = 512
+    reference_audio_path = "../data/white.wav"
+    target_audio_path = "../data/white_EQ.wav"
+
+    # 读取音频文件
+    reference_audio, _ = sf.read(reference_audio_path, dtype='float32')
+    target_audio, _ = sf.read(target_audio_path, dtype='float32')
+
+    eq_curve, compensated_audio = compute_frequency_eq(
+        reference_audio, target_audio,
+        SAMPLE_RATE, FFT_SIZE, WINDOW_SIZE,
+        plot_results=False
+    )
+    sf.write("../data/frequency_eq.wav", compensated_audio, SAMPLE_RATE)

neverlib/filter/README.md

@@ -0,0 +1,101 @@
+# neverlib.filter
+
+本项目包含音频滤波器的实现和自动EQ匹配算法, 主要基于 scipy.signal 进行封装和扩展, 提供便捷的音频滤波器设计、处理功能以及智能EQ补偿解决方案。
+
+## 主要功能
+
+### 滤波器类型
+- 低通滤波器 (Low Pass Filter, LPF)
+- 高通滤波器 (High Pass Filter, HPF)
+- 带通滤波器 (Band Pass Filter, BPF)
+  - 恒定裙边增益模式 (constant skirt gain, peak gain = Q)
+  - 恒定 0dB 峰值增益模式 (constant 0 dB peak gain)
+- 陷波滤波器 (Notch Filter)
+- 全通滤波器 (All Pass Filter, APF)
+- 峰值滤波器 (Peaking EQ)
+- 低切滤波器 (Low Shelf Filter)
+- 高切滤波器 (High Shelf Filter)
+
+### 核心文件说明
+- `filters.py`: 提供 EQFilter 类, 包含多种滤波器的设计和实现
+- `biquad.py`: 二阶节（Biquad）滤波器的实现, 支持逐点处理
+- `common.py`: 基础滤波器函数, 提供 numpy/scipy 和 torch 版本
+
+### 自动EQ匹配算法 (AudoEQ/)
+提供多种智能EQ匹配算法, 可以自动分析两个音频文件的频谱差异并生成最优的EQ补偿参数：
+
+#### 🧬 基于优化算法的EQ匹配
+- `auto_eq_ga_basic.py`: **基础遗传算法** - 使用DEAP库实现, 代码简洁, 适合学习和快速原型
+- `auto_eq_ga_advanced.py`: **高级遗传算法** - 面向对象设计, 包含日志、检查点、早停等生产级功能
+- `auto_eq_de.py`: **差分进化算法** - 使用scipy优化, 全局收敛性好, 适合高精度匹配
+
+#### 📊 基于频谱分析的EQ匹配
+- `auto_eq_spectral_direct.py`: **频谱直接补偿** - 基于STFT频谱分析, 直接计算频谱差异, 速度最快
+
+详细使用说明请参考 `AudoEQ/README.md`
+
+## 使用说明
+
+对于基础滤波需求, 推荐直接使用 scipy.signal 的原生函数：
+```python
+from scipy import signal
+
+# 设计巴特沃斯滤波器
+b, a = signal.butter(N=2, Wn=100, btype='high', fs=16000)
+# 应用滤波器
+filtered = signal.lfilter(b, a, audio)
+```
+
+对于需要批量处理或自定义参数的场景, 可以使用本库的封装：
+```python
+from neverlib.filter import EQFilter, BiquadFilter
+
+# 使用 EQFilter
+eq = EQFilter(fs=16000)
+b, a = eq.LowpassFilter(fc=300, Q=0.707)
+
+# 使用 BiquadFilter 进行逐点处理
+biquad = BiquadFilter(b, a)
+output = [biquad.process(x) for x in input_signal]
+```
+
+### 自动EQ匹配快速开始
+
+对于需要自动EQ匹配的场景, 可以直接运行AudoEQ中的脚本：
+
+```bash
+# 快速频谱匹配（推荐入门）
+cd AudoEQ
+python auto_eq_spectral_direct.py
+
+# 高精度优化匹配
+python auto_eq_de.py                    # 差分进化算法
+python auto_eq_ga_basic.py              # 基础遗传算法  
+python auto_eq_ga_advanced.py           # 高级遗传算法
+```
+
+使用前请修改脚本中的音频文件路径：
+```python
+SOURCE_AUDIO_PATH = "path/to/source.wav"     # 源音频
+TARGET_AUDIO_PATH = "path/to/target.wav"     # 目标音频
+OUTPUT_MATCHED_AUDIO_PATH = "path/to/output.wav"  # 输出音频
+```
+
+## 详细教程
+
+### 滤波器教程
+请参考 Documents/filter/ 目录下的 Jupyter notebooks：
+- `filter_family.ipynb`: 各类滤波器的设计和频率响应示例
+- `biquad.ipynb`: 二阶节滤波器的实现和验证
+- `scipy_filter_family.ipynb`: scipy 原生滤波器的使用示例
+
+### 自动EQ匹配教程
+请参考 `AudoEQ/README.md` 了解：
+- 各种EQ匹配算法的详细介绍和对比
+- 参数调优指南和性能优化建议
+- 常见问题解决方案和故障排除
+
+## 参考资料
+- [Audio-EQ-Cookbook](http://www.musicdsp.org/files/Audio-EQ-Cookbook.txt)
+- [beqdesigner](https://github.com/3ll3d00d/beqdesigner)
+- [torch-audiomentations](https://github.com/iver56/torch-audiomentations)

neverlib/filter/__init__.py

@@ -1,3 +1,8 @@
+'''
+Author: 凌逆战 | Never
+Date: 2025-03-17 19:23:33
+Description: 
+'''
 """
 节省路径
 from neverlib.filter import common
@@ -5,3 +10,5 @@ from neverlib.filter import common
 from neverlib.filter.common import *
 """
 from .common import *
+from .core import *
+from .biquad import *

neverlib/filter/biquad.py

@@ -0,0 +1,45 @@
+'''
+Author: 凌逆战 | Never
+Date: 2025-08-04 16:06:46
+encoding: utf-8
+Description: 双二阶滤波器
+公式: y[n] = b0*x[n] + b1*x[n-1] + b2*x[n-2] - a1*y[n-1] - a2*y[n-2]
+'''
+import numpy as np
+from scipy import signal
+
+
+class BiquadFilter():
+    def __init__(self, b, a):
+        self.b0, self.b1, self.b2 = b
+        _, self.a1, self.a2 = a
+        self.x1, self.x2, self.y1, self.y2 = 0, 0, 0, 0
+
+    def process(self, x):
+        y = (self.b0 * x + self.b1 * self.x1 + self.b2 * self.x2
+             - self.a1 * self.y1 - self.a2 * self.y2)
+        self.x2 = self.x1
+        self.x1 = x
+        self.y2 = self.y1
+        self.y1 = y
+        return y
+
+
+if __name__ == "__main__":
+    # 设计高通滤波器系数
+    fs = 16000  # 采样率
+    fc = 70  # 截止频率（Hz）
+    # 输入信号
+    input_signal = [0.5, 0.8, 1.0, 0.7, -0.2, -0.6, -0.8, -0.3, -0.3, -0.3, -0.3]
+
+    # 定义一个二阶高通滤波器(巴特沃斯)
+    b, a = signal.butter(2, fc, btype='highpass', analog=False, output='ba', fs=fs)
+
+    # 创建双二阶滤波器实例
+    biquad_filter = BiquadFilter(b, a)
+    output_signal_biquad = [biquad_filter.process(x) for x in input_signal]
+
+    # 使用signal.butter进行前向滤波
+    output_signal_butter = signal.lfilter(b, a, input_signal)
+
+    print("Equal Outputs:", np.allclose(output_signal_biquad, output_signal_butter, atol=1e-08))    # True

neverlib/filter/common.py

@@ -1,9 +1,8 @@
-# -*- coding:utf-8 -*-
-# Author:凌逆战 | Never
-# Date: 2024/10/16
-"""
-一些基础和通用的滤波器
-"""
+'''
+Author: 凌逆战 | Never
+Date: 2025-08-05 23:42:08
+Description: 一些基础和通用的滤波器
+'''
 import torch
 import numpy as np
 from scipy import signal