Datasets:
Formats:
json
Languages:
English
Size:
< 1K
Tags:
time-series
time-series-decomposition
benchmark
component-recovery
symbolic-regression
icml-2026
License:
| import numpy as np | |
| import pickle | |
| from dataclasses import dataclass, field | |
| from typing import Dict, Any, List, Optional, Sequence, Tuple | |
| from ..core import DecompResult | |
| from ..registry import MethodRegistry | |
| try: | |
| import faiss | |
| _HAS_FAISS = True | |
| except ImportError: | |
| _HAS_FAISS = False | |
| class GaborClusterConfig: | |
| fs: float = 1.0 | |
| win_len: int = 256 | |
| hop: int = 64 | |
| n_fft: Optional[int] = None | |
| window_type: str = "gaussian" | |
| gaussian_sigma: Optional[float] = None | |
| n_clusters: int = 8 | |
| max_atoms: int = 200_000 | |
| use_log_amp: bool = True | |
| random_state: int = 42 | |
| n_iter: int = 20 | |
| verbose: bool = False | |
| class GaborClusterModel: | |
| centroids: np.ndarray | |
| mu: np.ndarray | |
| sigma: np.ndarray | |
| cfg: GaborClusterConfig | |
| def save(self, path: str) -> None: | |
| np.savez_compressed( | |
| path, | |
| centroids=self.centroids.astype(np.float32), | |
| mu=self.mu.astype(np.float32), | |
| sigma=self.sigma.astype(np.float32), | |
| cfg=np.array([self.cfg], dtype=object), | |
| ) | |
| def load(path: str) -> "GaborClusterModel": | |
| data = np.load(path, allow_pickle=True) | |
| centroids = data["centroids"] | |
| mu = data["mu"] | |
| sigma = data["sigma"] | |
| cfg = data["cfg"][0] | |
| return GaborClusterModel(centroids=centroids, mu=mu, sigma=sigma, cfg=cfg) | |
| def _make_window(L: int, wtype: str, sigma: Optional[float]) -> np.ndarray: | |
| if wtype == "gaussian": | |
| if sigma is None: | |
| sigma = L / 6.0 | |
| n = np.arange(L) - (L - 1) / 2.0 | |
| w = np.exp(-0.5 * (n / sigma) ** 2) | |
| return w / np.sqrt((w ** 2).sum()) | |
| elif wtype == "hann": | |
| w = np.hanning(L) | |
| return w / np.sqrt((w ** 2).sum()) | |
| else: | |
| raise ValueError(f"Unsupported window_type={wtype}") | |
| def _stft_rfft(x: np.ndarray, L: int, hop: int, n_fft: Optional[int], window: np.ndarray) -> np.ndarray: | |
| x = np.asarray(x, dtype=float).ravel() | |
| N = len(x) | |
| if n_fft is None: | |
| n_fft = 1 << int(np.ceil(np.log2(L))) | |
| if N < L: | |
| n_frames = 1 | |
| else: | |
| n_frames = 1 + (N - L) // hop | |
| Z = np.empty((n_frames, n_fft // 2 + 1), dtype=np.complex64) | |
| for m in range(n_frames): | |
| start = m * hop | |
| seg = np.zeros(L, dtype=float) | |
| if start + L <= N: | |
| seg[:] = x[start:start + L] | |
| else: | |
| tail = N - start | |
| if tail > 0: | |
| seg[:tail] = x[start:] | |
| segw = seg * window | |
| Z[m, :] = np.fft.rfft(segw, n=n_fft) | |
| return Z | |
| def _istft_rfft(Z: np.ndarray, L: int, hop: int, n_fft: int, window: np.ndarray, length: int) -> np.ndarray: | |
| M, K_r = Z.shape | |
| x_rec = np.zeros(length + L, dtype=float) | |
| win_acc = np.zeros(length + L, dtype=float) | |
| for m in range(M): | |
| frame = np.fft.irfft(Z[m, :], n=n_fft).real[:L] | |
| start = m * hop | |
| x_rec[start:start + L] += frame * window | |
| win_acc[start:start + L] += window ** 2 | |
| nz = win_acc > 1e-12 | |
| x_out = np.zeros_like(x_rec) | |
| x_out[nz] = x_rec[nz] / win_acc[nz] | |
| return x_out[:length] | |
| def _extract_gabor_features(x: np.ndarray, cfg: GaborClusterConfig, window: np.ndarray) -> Tuple[np.ndarray, np.ndarray]: | |
| x = np.asarray(x, dtype=float).ravel() | |
| L = cfg.win_len | |
| hop = cfg.hop | |
| n_fft = cfg.n_fft or (1 << int(np.ceil(np.log2(L)))) | |
| Z = _stft_rfft(x, L, hop, n_fft, window) | |
| M, K_r = Z.shape | |
| amp = np.abs(Z) | |
| if cfg.use_log_amp: | |
| amp_feat = np.log1p(amp) | |
| else: | |
| amp_feat = amp | |
| if M > 1: | |
| t_idx = np.linspace(0.0, 1.0, M) | |
| else: | |
| t_idx = np.array([0.0]) | |
| if K_r > 1: | |
| f_idx = np.linspace(0.0, 1.0, K_r) | |
| else: | |
| f_idx = np.array([0.0]) | |
| T, F = np.meshgrid(t_idx, f_idx, indexing="ij") | |
| feats = np.stack([T.ravel().astype(np.float32), F.ravel().astype(np.float32), amp_feat.ravel().astype(np.float32)], axis=1) | |
| return feats, Z | |
| def _assign_clusters_faiss(feats: np.ndarray, model: GaborClusterModel) -> np.ndarray: | |
| if not _HAS_FAISS: | |
| raise ImportError("faiss is required for GABOR_CLUSTER.") | |
| X = (feats - model.mu) / model.sigma | |
| X = X.astype(np.float32) | |
| d = X.shape[1] | |
| index = faiss.IndexFlatL2(d) | |
| index.add(model.centroids.astype(np.float32)) | |
| D, I = index.search(X, 1) | |
| return I.ravel() | |
| def gabor_cluster_decompose(y: np.ndarray, params: Dict[str, Any]) -> DecompResult: | |
| if not _HAS_FAISS: | |
| raise ImportError("faiss is required for GABOR_CLUSTER.") | |
| cfg_dict = params.copy() | |
| model_path = cfg_dict.get("model_path") | |
| model = cfg_dict.get("model") | |
| max_clusters = cfg_dict.get("max_clusters") | |
| if model is None: | |
| if model_path: | |
| model = GaborClusterModel.load(model_path) | |
| else: | |
| raise ValueError("GABOR_CLUSTER requires 'model_path' or 'model' in params.") | |
| cfg = model.cfg | |
| x = np.asarray(y, dtype=float).ravel() | |
| N = len(x) | |
| L = cfg.win_len | |
| hop = cfg.hop | |
| n_fft = cfg.n_fft or (1 << int(np.ceil(np.log2(L)))) | |
| window = _make_window(L, cfg.window_type, cfg.gaussian_sigma) | |
| feats, Z = _extract_gabor_features(x, cfg, window) | |
| labels = _assign_clusters_faiss(feats, model) | |
| M, K_r = Z.shape | |
| K = model.centroids.shape[0] | |
| labels_2d = labels.reshape(M, K_r) | |
| amp = np.abs(Z) | |
| energy_per_cluster = np.zeros(K, dtype=float) | |
| for j in range(K): | |
| mask = (labels_2d == j) | |
| if np.any(mask): | |
| energy_per_cluster[j] = (amp[mask] ** 2).sum() | |
| if max_clusters is not None and max_clusters < K: | |
| keep_idx = np.argsort(energy_per_cluster)[-max_clusters:] | |
| keep_mask = np.zeros(K, dtype=bool) | |
| keep_mask[keep_idx] = True | |
| else: | |
| keep_mask = np.ones(K, dtype=bool) | |
| components: Dict[str, np.ndarray] = {} | |
| used_clusters = [] | |
| for j in range(K): | |
| if not keep_mask[j]: | |
| continue | |
| mask = (labels_2d == j).astype(np.float32) | |
| if not np.any(mask): | |
| continue | |
| Zj = Z * mask | |
| xj = _istft_rfft(Zj, L, hop, n_fft, window, N) | |
| components[f"Cluster_{j}"] = xj | |
| used_clusters.append(j) | |
| if components: | |
| sum_comp = np.zeros_like(x) | |
| for v in components.values(): | |
| sum_comp += v | |
| residual = x - sum_comp | |
| else: | |
| residual = x.copy() | |
| # Map to trend/season if possible (heuristic) | |
| trend_freq_thr = float(cfg_dict.get("trend_freq_thr", 0.08)) | |
| trend = np.zeros_like(x) | |
| season = np.zeros_like(x) | |
| for key, val in components.items(): | |
| cluster_idx = int(key.split("_")[1]) | |
| # Centroid freq is at index 1 (normalized freq) | |
| f_norm = float(model.centroids[cluster_idx, 1]) | |
| if f_norm <= trend_freq_thr: | |
| trend += val | |
| else: | |
| season += val | |
| return DecompResult( | |
| trend=trend, | |
| season=season, | |
| residual=residual, | |
| components=components, | |
| meta={ | |
| "method": "GABOR_CLUSTER", | |
| "n_clusters": K, | |
| "used_clusters": used_clusters, | |
| "max_clusters": max_clusters | |
| } | |
| ) | |