neverlib 0.2.8__py3-none-any.whl → 0.2.9__py3-none-any.whl

neverlib/.history/filter/auto_eq/ga_eq_basic_20250901110652.py

@@ -1,385 +0,0 @@
-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 neverlib.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)
-
-    wav_3956, sr = sf.read("../../data/3956_sweep.wav")
-    target_audio = wav_3956[:, 1]   # Talk 人耳
-    source_audio = wav_3956[:, 0]   # FF2 人嘴
-
-    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/.history/filter/common_20250806002134.py

@@ -1,37 +0,0 @@
-'''
-Author: 凌逆战 | Never
-Date: 2025-08-05 23:42:08
-Description: 一些基础和通用的滤波器
-'''
-import torch
-import numpy as np
-from scipy import signal
-import torchaudio.functional as F
-
-
-def HPFilter(wav, sr=16000, order=6, cutoff=100):
-    """
-    :param wav: (xxx,ch)
-    :param sr: 采样率
-    :param order: 滤波器阶数
-    :param cutoff: 截止频率
-    :return:
-    """
-    b, a = signal.butter(order, cutoff, btype='highpass', analog=False, output='ba', fs=sr)
-    wav = signal.lfilter(b, a, wav, axis=0)
-    return wav.astype(np.float32)
-
-
-def HPFilter_torch(wav, sr=16000, order=6, cutoff=100):
-    """
-    Args:
-        wav: (B,T)
-    """
-    b, a = signal.butter(order, cutoff, btype='highpass', analog=False, output='ba', fs=sr)
-
-    # 将滤波器系数转换为 torch 张量
-    b = torch.tensor(b, dtype=torch.float32)
-    a = torch.tensor(a, dtype=torch.float32)
-
-    filtered_signal = F.lfilter(wav, a, b)  # 应用低通滤波器
-    return filtered_signal

neverlib/.history/filter/common_20250821120448.py

@@ -1,49 +0,0 @@
-'''
-Author: 凌逆战 | Never
-Date: 2025-08-05 23:42:08
-Description: 一些基础和通用的滤波器
-'''
-import torch
-import numpy as np
-from scipy import signal
-import torchaudio.functional as F
-
-
-def HPFilter(wav, sr=16000, order=6, cutoff=100):
-    """
-    :param wav: (xxx,ch)
-    :param sr: 采样率
-    :param order: 滤波器阶数
-    :param cutoff: 截止频率
-    :return:
-    """
-    b, a = signal.butter(order, cutoff, btype='highpass', analog=False, output='ba', fs=sr)
-    wav = signal.lfilter(b, a, wav, axis=0)
-    return wav.astype(np.float32)
-
-
-def LPFilter(wav, sr=16000, order=6, cutoff=100):
-    """
-    :param wav: (xxx,ch)
-    :param sr: 采样率
-    :param order: 滤波器阶数
-    :param cutoff: 截止频率
-    :return:
-    """
-    b, a = signal.butter(order, cutoff, btype='lowpass', analog=False, output='ba', fs=sr)
-    wav = signal.lfilter(b, a, wav, axis=0)
-    return wav.astype(np.float32)
-
-def HPFilter_torch(wav, sr=16000, order=6, cutoff=100):
-    """
-    Args:
-        wav: (B,T)
-    """
-    b, a = signal.butter(order, cutoff, btype='highpass', analog=False, output='ba', fs=sr)
-
-    # 将滤波器系数转换为 torch 张量
-    b = torch.tensor(b, dtype=torch.float32)
-    a = torch.tensor(a, dtype=torch.float32)
-
-    filtered_signal = F.lfilter(wav, a, b)  # 应用低通滤波器
-    return filtered_signal

neverlib/.history/filter/common_20250821120453.py

@@ -1,49 +0,0 @@
-'''
-Author: 凌逆战 | Never
-Date: 2025-08-05 23:42:08
-Description: 一些基础和通用的滤波器
-'''
-import torch
-import numpy as np
-from scipy import signal
-import torchaudio.functional as F
-
-
-def HPFilter(wav, sr=16000, order=6, cutoff=100):
-    """
-    :param wav: (xxx,ch)
-    :param sr: 采样率
-    :param order: 滤波器阶数
-    :param cutoff: 截止频率
-    :return:
-    """
-    b, a = signal.butter(order, cutoff, btype='highpass', analog=False, output='ba', fs=sr)
-    wav = signal.lfilter(b, a, wav, axis=0)
-    return wav.astype(np.float32)
-
-
-def LPFilter(wav, sr=16000, order=6, cutoff=100):
-    """
-    :param wav: (xxx,ch)
-    :param sr: 采样率
-    :param order: 滤波器阶数
-    :param cutoff: 截止频率
-    :return:
-    """
-    b, a = signal.butter(order, cutoff, btype='lowpass', analog=False, output='ba', fs=sr)
-    wav = signal.lfilter(b, a, wav, axis=0)
-    return wav.astype(np.float32)
-
-def HPFilter_torch(wav, sr=16000, order=6, cutoff=100):
-    """
-    Args:
-        wav: (B,T)
-    """
-    b, a = signal.butter(order, cutoff, btype='highpass', analog=False, output='ba', fs=sr)
-
-    # 将滤波器系数转换为 torch 张量
-    b = torch.tensor(b, dtype=torch.float32)
-    a = torch.tensor(a, dtype=torch.float32)
-
-    filtered_signal = F.lfilter(wav, a, b)  # 应用低通滤波器
-    return filtered_signal

neverlib/.history/metrics/dnsmos_20250806001612.py

@@ -1,160 +0,0 @@
-'''
-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)