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

neverlib/data_analyze/spectral_analysis.py

@@ -4,22 +4,19 @@ Spectral Analysis Module
 
 提供音频频域特征提取和分析功能
 """
-
-import numpy as np
 import librosa
-import scipy.signal
+import numpy as np
 from scipy.fft import fft, fftfreq
 from typing import Tuple, Optional, Union
-import warnings
 
 
 class SpectralAnalyzer:
     """频谱分析器类"""
-    
+
     def __init__(self, sr: int = 22050, n_fft: int = 2048, hop_length: int = 512):
         """
         初始化频谱分析器
-        
+
         Args:
             sr: 采样率
             n_fft: FFT窗口大小
@@ -28,132 +25,132 @@ class SpectralAnalyzer:
         self.sr = sr
         self.n_fft = n_fft
         self.hop_length = hop_length
-    
+
     def compute_stft(self, audio: np.ndarray) -> np.ndarray:
         """
         计算短时傅里叶变换
-        
+
         Args:
             audio: 音频信号
-            
+
         Returns:
             STFT结果
         """
         return librosa.stft(audio, n_fft=self.n_fft, hop_length=self.hop_length)
-    
+
     def compute_magnitude_spectrum(self, audio: np.ndarray) -> Tuple[np.ndarray, np.ndarray]:
         """
         计算幅度谱
-        
+
         Args:
             audio: 音频信号
-            
+
         Returns:
             频率轴, 幅度谱
         """
         spectrum = fft(audio)
         magnitude = np.abs(spectrum)
-        freqs = fftfreq(len(audio), 1/self.sr)
-        
+        freqs = fftfreq(len(audio), 1 / self.sr)
+
         # 只返回正频率部分
         positive_freq_idx = freqs >= 0
         return freqs[positive_freq_idx], magnitude[positive_freq_idx]
-    
+
     def spectral_centroid(self, audio: np.ndarray) -> np.ndarray:
         """
         计算谱重心
-        
+
         Args:
             audio: 音频信号
-            
+
         Returns:
             谱重心数组
         """
         return librosa.feature.spectral_centroid(
             y=audio, sr=self.sr, hop_length=self.hop_length
         )[0]
-    
+
     def spectral_rolloff(self, audio: np.ndarray, roll_percent: float = 0.85) -> np.ndarray:
         """
         计算谱滚降
-        
+
         Args:
             audio: 音频信号
             roll_percent: 滚降百分比
-            
+
         Returns:
             谱滚降数组
         """
         return librosa.feature.spectral_rolloff(
             y=audio, sr=self.sr, hop_length=self.hop_length, roll_percent=roll_percent
         )[0]
-    
+
     def spectral_flatness(self, audio: np.ndarray) -> np.ndarray:
         """
         计算谱平坦度
-        
+
         Args:
             audio: 音频信号
-            
+
         Returns:
             谱平坦度数组
         """
         return librosa.feature.spectral_flatness(
             y=audio, hop_length=self.hop_length
         )[0]
-    
+
     def spectral_contrast(self, audio: np.ndarray, n_bands: int = 6) -> np.ndarray:
         """
         计算谱对比度
-        
+
         Args:
             audio: 音频信号
             n_bands: 频段数量
-            
+
         Returns:
             谱对比度矩阵
         """
         return librosa.feature.spectral_contrast(
             y=audio, sr=self.sr, hop_length=self.hop_length, n_bands=n_bands
         )
-    
+
     def mfcc_features(self, audio: np.ndarray, n_mfcc: int = 13) -> np.ndarray:
         """
         提取MFCC特征
-        
+
         Args:
             audio: 音频信号
             n_mfcc: MFCC系数数量
-            
+
         Returns:
             MFCC特征矩阵
         """
         return librosa.feature.mfcc(
             y=audio, sr=self.sr, n_mfcc=n_mfcc, hop_length=self.hop_length
         )
-    
+
     def mel_spectrogram(self, audio: np.ndarray, n_mels: int = 128) -> np.ndarray:
         """
         计算梅尔频谱图
-        
+
         Args:
             audio: 音频信号
             n_mels: 梅尔滤波器组数量
-            
+
         Returns:
             梅尔频谱图
         """
         return librosa.feature.melspectrogram(
             y=audio, sr=self.sr, n_mels=n_mels, hop_length=self.hop_length
         )
-    
+
     def chroma_features(self, audio: np.ndarray) -> np.ndarray:
         """
         提取色度特征
-        
+
         Args:
             audio: 音频信号
-            
+
         Returns:
             色度特征矩阵
         """
@@ -165,16 +162,16 @@ class SpectralAnalyzer:
 def compute_spectral_features(audio: np.ndarray, sr: int = 22050) -> dict:
     """
     计算完整的频域特征集合
-    
+
     Args:
         audio: 音频信号
         sr: 采样率
-        
+
     Returns:
         包含各种频域特征的字典
     """
     analyzer = SpectralAnalyzer(sr=sr)
-    
+
     features = {
         'spectral_centroid': analyzer.spectral_centroid(audio),
         'spectral_rolloff': analyzer.spectral_rolloff(audio),
@@ -184,27 +181,27 @@ def compute_spectral_features(audio: np.ndarray, sr: int = 22050) -> dict:
         'mel_spectrogram': analyzer.mel_spectrogram(audio),
         'chroma': analyzer.chroma_features(audio)
     }
-    
+
     return features
 
 
 def frequency_domain_stats(audio: np.ndarray, sr: int = 22050) -> dict:
     """
     计算频域统计信息
-    
+
     Args:
         audio: 音频信号
         sr: 采样率
-        
+
     Returns:
         频域统计信息字典
     """
     analyzer = SpectralAnalyzer(sr=sr)
     freqs, magnitude = analyzer.compute_magnitude_spectrum(audio)
-    
+
     # 计算功率谱密度
     power = magnitude ** 2
-    
+
     # 计算统计量
     stats = {
         'mean_frequency': np.average(freqs, weights=power),
@@ -212,7 +209,7 @@ def frequency_domain_stats(audio: np.ndarray, sr: int = 22050) -> dict:
         'peak_frequency': freqs[np.argmax(magnitude)],
         'bandwidth': freqs[np.where(power > 0.5 * np.max(power))][-1] - freqs[np.where(power > 0.5 * np.max(power))][0],
         'spectral_energy': np.sum(power),
-        'spectral_entropy': -np.sum((power/np.sum(power)) * np.log2(power/np.sum(power) + 1e-10))
+        'spectral_entropy': -np.sum((power / np.sum(power)) * np.log2(power / np.sum(power) + 1e-10))
     }
-    
-    return stats
+
+    return stats

neverlib/data_analyze/statistics.py

@@ -4,25 +4,20 @@ Statistics Analysis Module
 
 提供音频数据集统计分析功能
 """
-
+import json
 import numpy as np
-import librosa
-import os
 from pathlib import Path
-from typing import List, Dict, Tuple, Optional, Union
-import matplotlib.pyplot as plt
-from collections import defaultdict
-import json
-from .utils import rms_amplitude, dB
+from typing import List, Dict, Tuple, Optional
+from .temporal_features import rms_amplitude, dB
 
 
 class AudioStatistics:
     """音频统计分析类"""
-    
+
     def __init__(self, sr: int = 22050):
         """
         初始化统计分析器
-        
+
         Args:
             sr: 采样率
         """
@@ -30,53 +25,58 @@ class AudioStatistics:
         self.audio_data = []
         self.file_paths = []
         self.statistics = {}
-    
+
     def add_audio_file(self, file_path: str, audio_data: Optional[np.ndarray] = None):
         """
         添加音频文件到分析列表
-        
+
         Args:
             file_path: 音频文件路径
             audio_data: 音频数据（如果不提供则从文件加载）
         """
+        try:
+            import librosa
+        except Exception as e:
+            raise ImportError("需要安装 librosa 才能使用 add_audio_file: pip install librosa") from e
+
         if audio_data is None:
             try:
                 audio_data, _ = librosa.load(file_path, sr=self.sr)
             except Exception as e:
                 print(f"Error loading {file_path}: {e}")
                 return
-        
+
         self.audio_data.append(audio_data)
         self.file_paths.append(file_path)
-    
+
     def add_audio_directory(self, directory: str, extensions: List[str] = None):
         """
         批量添加目录中的音频文件
-        
+
         Args:
             directory: 音频文件目录
             extensions: 支持的文件扩展名
         """
         if extensions is None:
             extensions = ['.wav', '.mp3', '.flac', '.m4a', '.aac']
-        
+
         directory = Path(directory)
         for ext in extensions:
             for file_path in directory.glob(f'*{ext}'):
                 self.add_audio_file(str(file_path))
-    
+
     def compute_duration_statistics(self) -> Dict:
         """
         计算音频时长统计
-        
+
         Returns:
             时长统计信息
         """
         durations = [len(audio) / self.sr for audio in self.audio_data]
-        
+
         if not durations:
             return {}
-        
+
         stats = {
             'count': len(durations),
             'total_duration': sum(durations),
@@ -92,30 +92,30 @@ class AudioStatistics:
                 '95th': np.percentile(durations, 95)
             }
         }
-        
+
         return stats
-    
+
     def compute_amplitude_statistics(self) -> Dict:
         """
         计算幅度统计
-        
+
         Returns:
             幅度统计信息
         """
         all_amplitudes = []
         max_amplitudes = []
         rms_values = []
-        
+
         for audio in self.audio_data:
             all_amplitudes.extend(np.abs(audio).tolist())
             max_amplitudes.append(np.max(np.abs(audio)))
             rms_values.append(rms_amplitude(audio))
-        
+
         if not all_amplitudes:
             return {}
-        
+
         all_amplitudes = np.array(all_amplitudes)
-        
+
         stats = {
             'overall': {
                 'mean': np.mean(all_amplitudes),
@@ -144,33 +144,33 @@ class AudioStatistics:
                 'std_db': np.std([dB(rms) for rms in rms_values])
             }
         }
-        
+
         return stats
-    
+
     def compute_frequency_statistics(self) -> Dict:
         """
         计算频域统计
-        
+
         Returns:
             频域统计信息
         """
         spectral_centroids = []
         spectral_bandwidths = []
         spectral_rolloffs = []
-        
+
         for audio in self.audio_data:
             # 计算频谱特征
             centroid = librosa.feature.spectral_centroid(y=audio, sr=self.sr)[0]
             bandwidth = librosa.feature.spectral_bandwidth(y=audio, sr=self.sr)[0]
             rolloff = librosa.feature.spectral_rolloff(y=audio, sr=self.sr)[0]
-            
+
             spectral_centroids.extend(centroid.tolist())
             spectral_bandwidths.extend(bandwidth.tolist())
             spectral_rolloffs.extend(rolloff.tolist())
-        
+
         if not spectral_centroids:
             return {}
-        
+
         stats = {
             'spectral_centroid': {
                 'mean': np.mean(spectral_centroids),
@@ -191,17 +191,17 @@ class AudioStatistics:
                 'max': np.max(spectral_rolloffs)
             }
         }
-        
+
         return stats
-    
+
     def detect_outliers(self, feature: str = 'duration', threshold: float = 2.0) -> List[Tuple[str, float]]:
         """
         检测异常值
-        
+
         Args:
             feature: 要检测的特征 ('duration', 'max_amplitude', 'rms')
             threshold: Z-score阈值
-            
+
         Returns:
             异常文件列表 [(文件路径, 特征值)]
         """
@@ -213,23 +213,23 @@ class AudioStatistics:
             values = [rms_amplitude(audio) for audio in self.audio_data]
         else:
             raise ValueError(f"Unknown feature: {feature}")
-        
+
         values = np.array(values)
         mean_val = np.mean(values)
         std_val = np.std(values)
-        
+
         outliers = []
         for i, (path, val) in enumerate(zip(self.file_paths, values)):
             z_score = abs(val - mean_val) / (std_val + 1e-10)
             if z_score > threshold:
                 outliers.append((path, val))
-        
+
         return outliers
-    
+
     def generate_distribution_analysis(self) -> Dict:
         """
         生成分布分析
-        
+
         Returns:
             分布分析结果
         """
@@ -238,34 +238,34 @@ class AudioStatistics:
             'amplitude_distribution': self._analyze_distribution([np.max(np.abs(audio)) for audio in self.audio_data]),
             'rms_distribution': self._analyze_distribution([rms_amplitude(audio) for audio in self.audio_data])
         }
-        
+
         return analysis
-    
+
     def _analyze_distribution(self, values: List[float]) -> Dict:
         """
         分析数值分布
-        
+
         Args:
             values: 数值列表
-            
+
         Returns:
             分布分析结果
         """
         if not values:
             return {}
-        
+
         values = np.array(values)
-        
+
         # 计算偏度和峰度
         mean_val = np.mean(values)
         std_val = np.std(values)
-        
+
         # 偏度 (skewness)
         skewness = np.mean(((values - mean_val) / (std_val + 1e-10)) ** 3)
-        
+
         # 峰度 (kurtosis)
         kurtosis = np.mean(((values - mean_val) / (std_val + 1e-10)) ** 4) - 3
-        
+
         return {
             'mean': mean_val,
             'std': std_val,
@@ -273,15 +273,15 @@ class AudioStatistics:
             'kurtosis': kurtosis,
             'distribution_type': self._classify_distribution(skewness, kurtosis)
         }
-    
+
     def _classify_distribution(self, skewness: float, kurtosis: float) -> str:
         """
         分类分布类型
-        
+
         Args:
             skewness: 偏度
             kurtosis: 峰度
-            
+
         Returns:
             分布类型描述
         """
@@ -297,11 +297,11 @@ class AudioStatistics:
             return "light_tailed"
         else:
             return "unknown"
-    
+
     def compute_all_statistics(self) -> Dict:
         """
         计算所有统计信息
-        
+
         Returns:
             完整统计报告
         """
@@ -318,13 +318,13 @@ class AudioStatistics:
                 'rms': self.detect_outliers('rms')
             }
         }
-        
+
         return self.statistics
-    
+
     def export_statistics(self, output_path: str):
         """
         导出统计结果到JSON文件
-        
+
         Args:
             output_path: 输出文件路径
         """
@@ -342,9 +342,9 @@ class AudioStatistics:
                 return [convert_numpy(item) for item in obj]
             else:
                 return obj
-        
+
         stats_json = convert_numpy(self.statistics)
-        
+
         with open(output_path, 'w', encoding='utf-8') as f:
             json.dump(stats_json, f, indent=2, ensure_ascii=False)
 
@@ -352,47 +352,47 @@ class AudioStatistics:
 def quick_audio_stats(file_paths: List[str], sr: int = 22050) -> Dict:
     """
     快速音频统计分析
-    
+
     Args:
         file_paths: 音频文件路径列表
         sr: 采样率
-        
+
     Returns:
         统计结果
     """
     analyzer = AudioStatistics(sr=sr)
-    
+
     for file_path in file_paths:
         analyzer.add_audio_file(file_path)
-    
+
     return analyzer.compute_all_statistics()
 
 
-def compare_datasets(dataset1_paths: List[str], dataset2_paths: List[str], 
-                    sr: int = 22050) -> Dict:
+def compare_datasets(dataset1_paths: List[str], dataset2_paths: List[str],
+                     sr: int = 22050) -> Dict:
     """
     比较两个数据集
-    
+
     Args:
         dataset1_paths: 数据集1文件路径
         dataset2_paths: 数据集2文件路径
         sr: 采样率
-        
+
     Returns:
         比较结果
     """
     analyzer1 = AudioStatistics(sr=sr)
     analyzer2 = AudioStatistics(sr=sr)
-    
+
     for path in dataset1_paths:
         analyzer1.add_audio_file(path)
-    
+
     for path in dataset2_paths:
         analyzer2.add_audio_file(path)
-    
+
     stats1 = analyzer1.compute_all_statistics()
     stats2 = analyzer2.compute_all_statistics()
-    
+
     comparison = {
         'dataset1': stats1,
         'dataset2': stats2,
@@ -402,5 +402,5 @@ def compare_datasets(dataset1_paths: List[str], dataset2_paths: List[str],
             'mean_rms_diff': stats2['amplitude_stats']['rms_values']['mean'] - stats1['amplitude_stats']['rms_values']['mean']
         }
     }
-    
-    return comparison
+
+    return comparison

neverlib/data_analyze/temporal_features.py

@@ -7,13 +7,7 @@ Temporal Features Analysis Module
 
 提供音频时域特征提取和分析功能
 '''
-
-import warnings
-from typing import Tuple, Optional, Union
-from scipy import signal
 import numpy as np
-import librosa
-# from neverlib.utils.utils import dB
 
 
 def dB(level):
@@ -42,6 +36,11 @@ def rms_amplitude(wav, frame_length=512, hop_length=256):
     :param wav: (*, ch)
     :return: (frame_num,)
     """
+    try:
+        import librosa
+    except Exception as e:
+        raise ImportError("需要安装 librosa 才能使用 rms_amplitude: pip install librosa") from e
+
     # 分帧
     frame = librosa.util.frame(wav.flatten(), frame_length=frame_length, hop_length=hop_length)  # (frame_length, frame_num)
     rms_amp = np.sqrt(np.mean(frame**2, axis=0))  # (frame_num,)
@@ -82,6 +81,11 @@ def zero_crossing_rate(self, audio: np.ndarray) -> np.ndarray:
     Returns:
         过零率数组
     """
+    try:
+        import librosa
+    except Exception as e:
+        raise ImportError("需要安装 librosa 才能使用 zero_crossing_rate: pip install librosa") from e
+
     return librosa.feature.zero_crossing_rate(
         audio, frame_length=self.frame_length, hop_length=self.hop_length
     )[0]
@@ -97,6 +101,11 @@ def short_time_energy(self, audio: np.ndarray) -> np.ndarray:
     Returns:
         短时能量数组
     """
+    try:
+        import librosa
+    except Exception as e:
+        raise ImportError("需要安装 librosa 才能使用 short_time_energy: pip install librosa") from e
+
     # 分帧
     frames = librosa.util.frame(
         audio, frame_length=self.frame_length, hop_length=self.hop_length