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

neverlib/.history/utils/utils_20250904190053.py

@@ -0,0 +1,359 @@
+# -*- coding:utf-8 -*-
+# Author:凌逆战 | Never
+# Date: 2023/9/25
+"""
+folder处理
+"""
+import os
+import random
+import shutil
+import fnmatch
+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):
+    wav_list = []
+    for root, dirnames, filenames in os.walk(source_path):
+        # 实现列表特殊字符的过滤或筛选,返回符合匹配“.wav”字符列表
+        for filename in fnmatch.filter(filenames, end):
+            wav_list.append(os.path.join(root, filename))
+    if os.environ.get("LOCAL_RANK", "0") == "0":
+        print(source_path, len(wav_list))
+    if shuffle:
+        random.shuffle(wav_list)
+    return wav_list
+
+
+def get_audio_segments(sentence_len, wav_path_list, sr=16000, insert_silence=None):
+    """
+    从音频列表中随机拼接指定长度音频
+    Args:
+        sentence_len: 需要返回的音频长度
+        wav_path_list: 音频路径列表
+        sr: 采样率
+        insert_silence: 插入静音的长度
+    Returns:返回指定长度的音频
+    """
+    merge_wav_len = 0
+    wav_list = []
+    while merge_wav_len < sentence_len:
+        wav_path = random.choice(wav_path_list)
+        wav, wav_sr = sf.read(wav_path, always_2d=True, dtype='float32')
+        assert wav_sr == sr, f"音频采样率是{wav_sr}, 期望{sr}"
+        merge_wav_len += len(wav)
+        wav_list.append(wav)
+        if insert_silence is not None:
+            silence_len = random.randint(0, insert_silence)
+            silence = np.zeros((silence_len, ), dtype=np.float32)
+            merge_wav_len += silence_len
+            wav_list.append(silence)
+    wav = np.concatenate(wav_list, axis=0)
+    if len(wav) > sentence_len:
+        # 随机截取clean_len
+        start = random.randint(0, merge_wav_len - sentence_len)
+        wav = wav[start:start + sentence_len, :]
+    return wav
+
+
+def rename_files_and_folders(directory, replace='_-', replacement='_'):
+    # 将路径的指定字符替换为指定字符
+    for root, dirs, files in os.walk(directory):
+        for filename in files:
+            if replace in filename:
+                new_filename = filename.replace(replace, replacement)
+                old_path = os.path.join(root, filename)
+                new_path = os.path.join(root, new_filename)
+                os.rename(old_path, new_path)
+                print(f'Renamed file: {old_path} -> {new_path}')
+
+        for folder in dirs:
+            if replace in folder:
+                new_folder = folder.replace(replace, replacement)
+                old_path = os.path.join(root, folder)
+                new_path = os.path.join(root, new_folder)
+                os.rename(old_path, new_path)
+                print(f'Renamed folder: {old_path} -> {new_path}')
+
+
+def get_file_time(file_path):
+    # 获取最后修改时间
+    mod_time = os.path.getmtime(file_path)
+    # 转为data_time格式: 年-月-日-时-分-秒
+    datetime_dt = datetime.fromtimestamp(mod_time)
+
+    # 如果时间早于2024-09-04 02:00:00, 则删除
+    # if datetime_dt < datetime(2024, 9, 4, 2, 0, 0):
+    #     print(file_path)
+    return datetime_dt
+
+
+def TrainValSplit(dataset_dir, train_dir, val_dir, percentage=0.9):
+    """ 分割数据集为训练集和验证集
+    :param dataset_dir: 源数据集地址
+    :param train_dir: 训练集地址
+    :param val_dir: 验证集地址
+    :param percentage: 分割百分比
+    """
+    wav_path_list = get_path_list(dataset_dir, end="*.wav", shuffle=True)
+    total_wav_num = len(wav_path_list)
+    # 计算训练集和验证集的分割点
+    split_idx = int(total_wav_num * percentage)
+    train_path_list, val_path_list = wav_path_list[:split_idx], wav_path_list[split_idx:]
+
+    for train_wavpath in tqdm(train_path_list, desc="Copying train wav"):
+        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="Copying val wav"):
+        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)
+
+    print("Done!")
+
+
+def TrainValTestSplit(dataset_dir, train_dir, val_dir, test_dir, percentage=[0.8, 0.1, 0.1]):
+    """ 分割数据集为训练集、验证集和测试集
+    :param dataset_dir: 源数据集地址
+    :param train_dir: 训练集地址
+    :param val_dir: 验证集地址
+    :param test_dir: 测试集地址
+    :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)}个文件")
+
+
+def get_leaf_folders(directory):
+    # 获取最底层的文件夹路径
+    leaf_folders = []
+    for root, dirs, _ in os.walk(directory):
+        if not dirs:  # 如果当前文件夹没有子文件夹
+            leaf_folders.append(root)
+    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]
+    Example:
+        # 两路分割示例
+        DatasetSplit(
+            source_dir=source_dataset_path,
+            split_dirs=[target_train_path, target_val_path],
+            percentage=[0.9, 0.1]
+        )
+
+        # 三路分割示例
+        DatasetSplit(
+            source_dir=source_dataset_path,
+            split_dirs=[target_train_path, target_val_path, target_test_path],
+            percentage=[0.8, 0.1, 0.1]
+        )
+
+        # 使用默认比例的两路分割
+        DatasetSplit(
+            source_dir=source_dataset_path,
+            split_dirs=[target_train_path, target_val_path]
+        )
+    """
+    if percentage is None:
+        percentage = [0.9, 0.1] if len(split_dirs) == 2 else [0.8, 0.1, 0.1]
+
+    # 验证输入参数
+    if len(split_dirs) not in [2, 3]:
+        raise ValueError("只支持2路或3路分割（训练集/验证集 或 训练集/验证集/测试集）")
+    if len(percentage) != len(split_dirs):
+        raise ValueError("分割比例数量必须与目标目录数量相同")
+    if sum(percentage) != 1.0:
+        raise ValueError("分割比例之和必须等于1.0")
+
+    # 获取并打乱文件夹列表
+    leaf_folder_list = sorted(get_leaf_folders(source_dir))
+    random.seed(10086)
+    random.shuffle(leaf_folder_list)
+    total_folder_num = len(leaf_folder_list)
+
+    # 计算分割点
+    split_indices = []
+    acc_percentage = 0
+    for p in percentage[:-1]:  # 最后一个比例不需要计算
+        acc_percentage += p
+        split_indices.append(int(total_folder_num * acc_percentage))
+
+    # 分割文件夹列表
+    split_folder_lists = []
+    start_idx = 0
+    for end_idx in split_indices:
+        split_folder_lists.append(leaf_folder_list[start_idx:end_idx])
+        start_idx = end_idx
+    split_folder_lists.append(leaf_folder_list[start_idx:])  # 添加最后一部分
+
+    # 复制文件夹
+    split_names = ['train', 'val', 'test']
+    for folders, target_dir, split_name in zip(split_folder_lists, split_dirs, split_names[:len(split_dirs)]):
+        for folder in tqdm(folders, desc=f"Copying {split_name} folders"):
+            target_folder = folder.replace(source_dir, target_dir)
+            os.makedirs(os.path.dirname(target_folder), exist_ok=True)
+            shutil.copytree(folder, target_folder)
+
+    # 打印统计信息
+    print(f"Total folders: {total_folder_num}")
+    for folders, split_name in zip(split_folder_lists, split_names[:len(split_dirs)]):
+        print(f"{split_name.capitalize()} folders: {len(folders)}")
+
+
+def pcm2wav(pcm_path, wav_path, sr=16000, channels=1, subtype='PCM_16'):
+    """
+    将pcm文件转换为wav文件
+    :param pcm_path: pcm文件路径
+    :param wav_path: wav文件路径
+    :param sr: 采样率
+    :param channels: 声道数
+    :param subtype: 子类型
+    """
+    pcm_data = np.fromfile(pcm_path, dtype=np.int16)
+    pcm_data = pcm_data.reshape(-1, channels)  # 支持多通道
+    sf.write(wav_path, pcm_data, sr, subtype=subtype)
+
+
+def wav2pcm(wav_path, pcm_path):
+    """
+    将wav文件转换为pcm文件
+    :param wav_path: wav文件路径
+    :param pcm_path: pcm文件路径
+    """
+    data, _ = sf.read(wav_path, dtype='int16')
+    data.tofile(pcm_path)
+
+
+def save_weight_histogram(model, save_dir, mode=["params", "buffers"], ignore_name=["scale", "bias"], bins=100):
+    """
+    保存模型权重分布直方图
+    Args:
+        model: PyTorch模型
+        save_dir: 保存路径
+        mode: 保存模式, 可选值为["params", "buffers"]
+        bins: 直方图bin数量
+    """
+    import matplotlib.pyplot as plt
+    # 如果路径存在, 则删除
+    if os.path.exists(save_dir):
+        shutil.rmtree(save_dir)
+
+    if "params" in mode:
+        os.makedirs(os.path.join(save_dir, "param"), exist_ok=True)
+        for name, param in model.named_parameters():
+            if any(ignore in name for ignore in ignore_name):
+                continue
+            param = param.cpu().data.flatten().numpy()
+            param_min = param.min()
+            param_max = param.max()
+            param_mean = param.mean()
+            param_std = param.std()
+
+            # 保存模型参数到地址
+            # 绘制直方图
+            plt.title(name)
+            plt.xlabel("value")
+            plt.ylabel("count")
+            plt.grid(alpha=0.5)
+            # 在右上角添加统计信息
+            plt.text(1, 1, f"max: {param_max:.2f}\n \
+                            min: {param_min:.2f}\n \
+                            mean: {param_mean:.2f}\n \
+                            std: {param_std:.2f}",
+                     ha='right', va='top', transform=plt.gca().transAxes)
+            plt.hist(param, bins=bins)
+            plt.savefig(os.path.join(save_dir, "param", f"{name}.png"))
+            plt.close()
+    if "buffers" in mode:
+        os.makedirs(os.path.join(save_dir, "buffer"), exist_ok=True)
+        for name, buffer in model.named_buffers():
+            if "running_mean" not in name and "running_var" not in name:
+                continue
+            buffer = buffer.cpu().data.flatten().numpy()
+
+            # 计算统计数据
+            buffer_min = buffer.min()
+            buffer_max = buffer.max()
+            buffer_mean = buffer.mean()
+            buffer_std = buffer.std()
+
+            # 绘制直方图
+            plt.title(name)
+            plt.xlabel("value")
+            plt.ylabel("count")
+            plt.grid(alpha=0.5)
+            # 在右上角添加统计信息
+            plt.text(1, 1, f"max: {buffer_max:.2f}\n \
+                            min: {buffer_min:.2f}\n \
+                            mean: {buffer_mean:.2f}\n \
+                            std: {buffer_std:.2f}",
+                     ha='right', va='top', transform=plt.gca().transAxes)
+            plt.hist(buffer, bins=bins)
+            plt.savefig(os.path.join(save_dir, "buffer", f"{name}.png"))
+            plt.close()

neverlib/.specstory/history/2025-08-22_02-10Z-/345/256/214/345/226/204/345/207/275/346/225/260/347/232/204/345/212/237/350/203/275/345/222/214/345/217/230/351/207/217/345/220/215/345/273/272/350/256/256.md

@@ -0,0 +1,247 @@
+<!-- Generated by SpecStory -->
+
+# 完善函数的功能和变量名建议 (2025-08-22 02:10Z)
+
+_**User**_
+
+帮我完善这个函数，包括功能建议和变量名建议
+
+---
+
+_**Assistant**_
+
+我来帮你完善这个函数。让我先仔细分析一下当前的代码，然后提供改进建议。
+
+
+---
+
+Read file: audio_aug/audio_aug.py
+
+---
+
+基于对代码的分析，我来为你的 `snr_aug_changeClean` 函数提供完善建议：
+
+## 功能改进建议
+
+### 1. 参数验证和类型提示
+- 添加参数类型提示
+- 增加参数范围验证
+- 添加更详细的错误信息
+
+### 2. 功能增强
+- 支持批量处理
+- 添加可选的功率计算方法
+- 增加日志记录功能
+- 支持不同的归一化策略
+
+### 3. 性能优化
+- 使用向量化操作
+- 添加缓存机制（如果需要重复计算）
+
+## 变量名改进建议
+
+### 当前变量名问题：
+- `clean_scale` → `clean_amplitude_factor` 或 `clean_gain`
+- `noisy` → `noisy_signal` 或 `augmented_signal`
+- `scale_factor` → `clip_prevention_factor` 或 `normalization_factor`
+
+## 完善后的函数代码
+
+```python:audio_aug/audio_aug.py
+def snr_aug_changeClean(
+    clean_signal: np.ndarray, 
+    noise_signal: np.ndarray, 
+    target_snr_db: float, 
+    clip_check: bool = True,
+    power_method: str = "mean",
+    eps: float = 1e-8
+) -> tuple[np.ndarray, np.ndarray]:
+    """
+    保持噪声不变，改变纯净语音的幅度以达到目标信噪比
+    
+    Args:
+        clean_signal: 纯净语音信号，形状为 (T,) 或 (T, C)
+        noise_signal: 噪声信号，形状必须与clean_signal相同
+        target_snr_db: 目标信噪比，单位为dB
+        clip_check: 是否进行削波检查，默认True
+        power_method: 功率计算方法，"mean"或"rms"，默认"mean"
+        eps: 数值稳定性常数，默认1e-8
+    
+    Returns:
+        tuple: (增强后的含噪信号, 调整后的纯净信号)
+        
+    Raises:
+        ValueError: 当参数无效时
+        AssertionError: 当信号形状不匹配时
+    """
+    # 参数验证
+    if target_snr_db < -50 or target_snr_db > 100:
+        raise ValueError(f"目标信噪比应在-50到100dB之间，当前值: {target_snr_db}")
+    
+    if clean_signal.shape != noise_signal.shape:
+        raise AssertionError(f"信号形状不匹配: clean_signal{clean_signal.shape} != noise_signal{noise_signal.shape}")
+    
+    # 计算信号功率
+    if power_method == "mean":
+        clean_power = np.mean(clean_signal ** 2)
+        noise_power = np.mean(noise_signal ** 2)
+    elif power_method == "rms":
+        clean_power = np.sqrt(np.mean(clean_signal ** 2)) ** 2
+        noise_power = np.sqrt(np.mean(noise_signal ** 2)) ** 2
+    else:
+        raise ValueError(f"不支持的功率计算方法: {power_method}，请使用 'mean' 或 'rms'")
+    
+    # 计算纯净信号需要的幅度因子
+    clean_amplitude_factor = np.sqrt(
+        noise_power * 10 ** (target_snr_db / 10) / (clean_power + eps)
+    )
+    
+    # 生成含噪信号
+    augmented_signal = clean_signal * clean_amplitude_factor + noise_signal
+    
+    # 削波检查和预防
+    if clip_check:
+        max_amplitude = np.max(np.abs(augmented_signal))
+        if max_amplitude > 1.0:
+            normalization_factor = 1.0 / max_amplitude
+            augmented_signal *= normalization_factor
+            # 同时调整纯净信号以保持一致性
+            adjusted_clean_signal = clean_signal * clean_amplitude_factor * normalization_factor
+        else:
+            adjusted_clean_signal = clean_signal * clean_amplitude_factor
+    else:
+        adjusted_clean_signal = clean_signal * clean_amplitude_factor
+    
+    return augmented_signal, adjusted_clean_signal
+```
+
+## 主要改进点总结
+
+1. **参数验证**: 添加了信噪比范围检查和功率计算方法验证
+2. **类型提示**: 使用Python类型提示提高代码可读性
+3. **变量命名**: 使用更清晰、描述性的变量名
+4. **功能扩展**: 支持不同的功率计算方法（均值或RMS）
+5. **错误处理**: 提供更详细的错误信息和异常处理
+6. **文档完善**: 详细的docstring说明参数、返回值和异常
+7. **代码结构**: 更清晰的逻辑分组和注释
+
+这些改进使函数更加健壮、可读和可维护，同时保持了原有的核心功能。
+
+---
+
+_**User**_
+
+均值或RMS 有区别吗？
+
+---
+
+_**Assistant**_
+
+是的，均值和RMS在计算信号功率时确实有区别！让我详细解释一下：
+
+## 均值和RMS的区别
+
+### 1. **均值方法 (Mean)**
+```python
+clean_power = np.mean(clean_signal ** 2)
+```
+- 计算所有样本点平方值的算术平均值
+- 对异常值（outliers）比较敏感
+- 适用于信号幅度相对稳定的情况
+
+### 2. **RMS方法 (Root Mean Square)**
+```python
+clean_power = np.sqrt(np.mean(clean_signal ** 2))
+```
+- 先计算平方值的均值，再开平方根
+- 更准确地反映信号的有效值
+- 在音频处理中更常用，因为RMS值与感知响度更相关
+
+## 实际差异示例
+
+让我用一个简单的例子来说明：
+
+```python
+import numpy as np
+
+# 模拟一个音频信号
+signal = np.array([0.1, 0.2, 0.15, 0.25, 0.18])
+
+# 均值方法
+mean_power = np.mean(signal ** 2)
+print(f"均值功率: {mean_power:.6f}")
+
+# RMS方法  
+rms_power = np.sqrt(np.mean(signal ** 2)) ** 2
+print(f"RMS功率: {rms_power:.6f}")
+
+# 注意：RMS功率实际上等于均值功率！
+print(f"两者相等: {np.isclose(mean_power, rms_power)}")
+```
+
+## 关键发现
+
+**实际上，对于功率计算，均值和RMS是等价的！**
+
+- `np.mean(signal ** 2)` = 均值功率
+- `np.sqrt(np.mean(signal ** 2)) ** 2` = RMS功率
+
+这是因为：
+1. RMS = √(均值(signal²))
+2. RMS功率 = RMS² = (√(均值(signal²)))² = 均值(signal²)
+
+## 建议
+
+既然两种方法结果相同，我建议简化函数：
+
+```python:audio_aug/audio_aug.py
+def snr_aug_changeClean(
+    clean_signal: np.ndarray, 
+    noise_signal: np.ndarray, 
+    target_snr_db: float, 
+    clip_check: bool = True,
+    eps: float = 1e-8
+) -> tuple[np.ndarray, np.ndarray]:
+    """
+    保持噪声不变，改变纯净语音的幅度以达到目标信噪比
+    
+    Args:
+        clean_signal: 纯净语音信号
+        noise_signal: 噪声信号
+        target_snr_db: 目标信噪比(dB)
+        clip_check: 是否进行削波检查
+        eps: 数值稳定性常数
+    
+    Returns:
+        tuple: (增强后的含噪信号, 调整后的纯净信号)
+    """
+    # 参数验证
+    if target_snr_db < -50 or target_snr_db > 100:
+        raise ValueError(f"目标信噪比应在-50到100dB之间，当前值: {target_snr_db}")
+    
+    if clean_signal.shape != noise_signal.shape:
+        raise AssertionError(f"信号形状不匹配: clean_signal{clean_signal.shape} != noise_signal{noise_signal.shape}")
+    
+    # 计算信号功率（使用均值方法即可）
+    clean_power = np.mean(clean_signal ** 2)
+    noise_power = np.mean(noise_signal ** 2)
+    
+    # 计算纯净信号需要的幅度因子
+    clean_amplitude_factor = np.sqrt(
+        noise_power * 10 ** (target_snr_db / 10) / (clean_power + eps)
+    )
+    
+    # ... 其余代码保持不变 ...
+```
+
+## 总结
+
+- **均值和RMS在功率计算上结果相同**
+- **不需要提供两种方法选择**
+- **均值方法更直接，计算效率更高**
+- **在音频处理中，均值功率是标准做法**
+
+所以之前的建议中关于功率计算方法的选择是多余的，直接使用均值方法即可。
+
+---
+

neverlib/.specstory/history/2025-08-26_11-54Z-oserror-missing-shared-object-file.md

@@ -0,0 +1,87 @@
+<!-- Generated by SpecStory -->
+
+# OSError: missing shared object file (2025-08-26 11:54Z)
+
+_**User**_
+
+OSError: libc++.so.1: cannot open shared object file: No such file or directory
+
+
+---
+
+_**Assistant**_
+
+我看到您遇到了一个关于 `libc++.so.1` 共享库文件缺失的错误。这是一个常见的系统依赖问题。让我先查看一下您的代码文件，了解具体情况，然后帮您解决这个问题。
+
+
+---
+
+Read file: Docs/vad/VAD_tenVAD.ipynb
+
+---
+
+我看到您的代码中使用了 `ten_vad` 模块。这个 `libc++.so.1` 错误通常是因为系统缺少 C++ 标准库的共享库文件。让我检查一下您的系统环境并提供解决方案。
+
+
+---
+
+```bash
+ldconfig -p | grep libc++
+```
+
+---
+
+_**User**_
+
+(py311torch211) never@172-16-64-33:/data03/never/Desktop/neverlib/neverlib$ ldconfig -p | grep libc++
+(py311torch211) never@172-16-64-33:/data03/never/Desktop/neverlib/neverlib$ 
+
+---
+
+_**Assistant**_
+
+看起来您的系统中没有找到 `libc++.so.1` 文件。这个错误通常发生在使用预编译的 C++ 库（如某些深度学习框架或音频处理库）时。让我帮您解决这个问题。
+
+有几种解决方案：
+
+## 方案1：安装 libc++ 开发库
+```bash
+# Ubuntu/Debian 系统
+sudo apt-get update
+sudo apt-get install libc++-dev libc++abi-dev
+
+# 或者安装 clang 相关包
+sudo apt-get install clang libc++1 libc++abi1
+```
+
+## 方案2：创建符号链接（如果系统中已有类似版本）
+```bash
+# 检查是否有其他版本的 libc++
+ls -la /usr/lib/x86_64-linux-gnu/ | grep libc++
+
+# 如果有类似版本，创建符号链接
+sudo ln -s /usr/lib/x86_64-linux-gnu/libc++.so.X /usr/lib/x86_64-linux-gnu/libc++.so.1
+```
+
+## 方案3：设置 LD_LIBRARY_PATH
+```bash
+# 如果库文件在其他位置，可以设置环境变量
+export LD_LIBRARY_PATH=/path/to/libc++:$LD_LIBRARY_PATH
+```
+
+## 方案4：重新安装 ten_vad 相关依赖
+```bash
+# 重新安装可能包含 C++ 库的包
+pip uninstall ten-vad
+pip install ten-vad --no-cache-dir
+
+# 或者从源码编译安装
+pip install ten-vad --no-binary :all:
+```
+
+建议您先尝试方案1，安装系统级的 C++ 库。如果问题仍然存在，请告诉我具体的错误信息，我可以提供更针对性的解决方案。
+
+您想先尝试哪种方案？
+
+---
+