Datasets:
Formats:
json
Languages:
English
Size:
< 1K
Tags:
time-series
time-series-decomposition
benchmark
component-recovery
symbolic-regression
icml-2026
License:
| # gabor_cluster.py | |
| from __future__ import annotations | |
| import numpy as np | |
| from dataclasses import dataclass | |
| from typing import List, Dict, Optional, Sequence, Tuple | |
| try: | |
| import faiss # faiss-cpu or faiss-gpu | |
| except ImportError as e: | |
| faiss = None | |
| class GaborClusterConfig: | |
| fs: float = 1.0 # sampling freq | |
| win_len: int = 256 # window length L | |
| hop: int = 64 # hop size a | |
| n_fft: Optional[int] = None | |
| window_type: str = "gaussian" # "gaussian" | "hann" | |
| gaussian_sigma: Optional[float] = None | |
| n_clusters: int = 8 # K | |
| max_atoms: int = 200_000 # max TF points to use in training | |
| use_log_amp: bool = True # log(1+|Z|) | |
| random_state: int = 42 # seed for reproducibility | |
| # training iterations for faiss KMeans | |
| n_iter: int = 20 | |
| verbose: bool = False | |
| class GaborClusterModel: | |
| """ | |
| Global clustering model learned from many series. | |
| """ | |
| centroids: np.ndarray # (K, d) | |
| mu: np.ndarray # (d,) | |
| sigma: np.ndarray # (d,) | |
| cfg: GaborClusterConfig # Gabor & feature config | |
| 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) | |
| class DecompResult: | |
| components: Dict[str, np.ndarray] | |
| residual: np.ndarray | |
| meta: Dict | |
| def gabor_components_to_TS( | |
| components: Dict[str, np.ndarray], | |
| model: GaborClusterModel, | |
| trend_freq_thr: float = 0.08, | |
| ) -> Dict[str, Optional[np.ndarray]]: | |
| """ | |
| Collapse per-cluster components into trend / seasonal buckets based on centroid frequency. | |
| """ | |
| import re | |
| trend = None | |
| seasonal = None | |
| for key, value in components.items(): | |
| match = re.match(r"Cluster_(\d+)$", key) | |
| if not match: | |
| continue | |
| cluster_idx = int(match.group(1)) | |
| f_norm = float(model.centroids[cluster_idx, 1]) | |
| if f_norm <= trend_freq_thr: | |
| trend = value if trend is None else trend + value | |
| else: | |
| seasonal = value if seasonal is None else seasonal + value | |
| return {"trend": trend, "seasonal": seasonal} | |
| # ---------------- STFT / ISTFT utilities ---------------- # | |
| 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: | |
| """ | |
| Real-input STFT using rfft. Output shape: (M, K_r), where K_r = n_fft//2 + 1 | |
| """ | |
| 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: | |
| """ | |
| Overlap-add ISTFT for rfft coefficients. | |
| Z: (M, K_r), K_r = n_fft//2 + 1 | |
| """ | |
| 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] | |
| # ---------------- Feature extraction ---------------- # | |
| def _extract_gabor_features( | |
| x: np.ndarray, | |
| cfg: GaborClusterConfig, | |
| window: np.ndarray | |
| ) -> Tuple[np.ndarray, np.ndarray]: | |
| """ | |
| For a single series x, compute STFT and return: | |
| - features: (N_atoms, d) matrix | |
| - Z: complex STFT matrix (M, K_r) | |
| Feature: [t_norm, f_norm, log_amp or amp] | |
| """ | |
| x = np.asarray(x, 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)))) | |
| Z = _stft_rfft(x, L, hop, n_fft, window) # (M, K_r) | |
| M, K_r = Z.shape | |
| amp = np.abs(Z) | |
| if cfg.use_log_amp: | |
| amp_feat = np.log1p(amp) | |
| else: | |
| amp_feat = amp | |
| # normalized time/freq coordinates | |
| 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") # (M,K_r) | |
| feats = np.stack( | |
| [ | |
| T.ravel().astype(np.float32), | |
| F.ravel().astype(np.float32), | |
| amp_feat.ravel().astype(np.float32), | |
| ], | |
| axis=1, | |
| ) # (M*K_r, 3) | |
| return feats, Z | |
| # ---------------- FAISS K-means training ---------------- # | |
| def train_gabor_clusters( | |
| series_list: Sequence[np.ndarray], | |
| cfg: GaborClusterConfig, | |
| ) -> GaborClusterModel: | |
| """ | |
| Learn global Gabor-atom clusters from a list of 1D series. | |
| Steps: | |
| - For each series: STFT -> [t_norm, f_norm, log_amp] features | |
| - Concatenate across all series | |
| - Subsample up to cfg.max_atoms | |
| - Standardize features | |
| - Run FAISS k-means to get centroids | |
| Returns: | |
| GaborClusterModel | |
| """ | |
| if faiss is None: | |
| raise ImportError( | |
| "faiss is not installed. Please install faiss-cpu or faiss-gpu before " | |
| "using train_gabor_clusters." | |
| ) | |
| if len(series_list) == 0: | |
| raise ValueError("series_list is empty.") | |
| L = cfg.win_len | |
| window = _make_window(L, cfg.window_type, cfg.gaussian_sigma) | |
| feat_list = [] | |
| for x in series_list: | |
| feats, _ = _extract_gabor_features(x, cfg, window) | |
| feat_list.append(feats) | |
| X = np.concatenate(feat_list, axis=0) # (N_atoms, d) | |
| N_atoms, d = X.shape | |
| if cfg.max_atoms is not None and N_atoms > cfg.max_atoms: | |
| rng = np.random.default_rng(cfg.random_state) | |
| idx = rng.choice(N_atoms, cfg.max_atoms, replace=False) | |
| X = X[idx] | |
| N_atoms = X.shape[0] | |
| # standardize | |
| mu = X.mean(axis=0) | |
| sigma = X.std(axis=0) + 1e-8 | |
| X_norm = (X - mu) / sigma | |
| X_norm = X_norm.astype(np.float32) | |
| # FAISS KMeans | |
| k = cfg.n_clusters | |
| if cfg.verbose: | |
| print(f"[GaborCluster] Training FAISS KMeans with K={k}, N={N_atoms}, d={d}") | |
| km = faiss.Kmeans( | |
| d=d, | |
| k=k, | |
| niter=cfg.n_iter, | |
| verbose=cfg.verbose, | |
| seed=cfg.random_state, | |
| ) | |
| km.train(X_norm) | |
| centroids = km.centroids # (k, d) | |
| return GaborClusterModel( | |
| centroids=centroids, | |
| mu=mu, | |
| sigma=sigma, | |
| cfg=cfg, | |
| ) | |
| # ---------------- Per-series decomposition ---------------- # | |
| def _assign_clusters_faiss( | |
| feats: np.ndarray, | |
| model: GaborClusterModel | |
| ) -> np.ndarray: | |
| """ | |
| Assign each feature vector to nearest centroid using FAISS IndexFlatL2. | |
| feats: (N_atoms, d) | |
| Returns: labels (N_atoms,) in [0, K-1] | |
| """ | |
| if faiss is None: | |
| raise ImportError( | |
| "faiss is not installed. Please install faiss-cpu or faiss-gpu before " | |
| "using gabor_cluster_decompose." | |
| ) | |
| 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) | |
| labels = I.ravel() | |
| return labels | |
| def gabor_cluster_decompose( | |
| x: np.ndarray, | |
| model: GaborClusterModel, | |
| max_clusters: Optional[int] = None, | |
| ) -> DecompResult: | |
| """ | |
| Decompose a single series x by: | |
| - computing Gabor STFT | |
| - assigning each TF atom to nearest global centroid | |
| - reconstructing each cluster as one component via ISTFT | |
| If max_clusters is not None, only keep the largest-energy clusters and | |
| merge the rest into the residual. | |
| """ | |
| cfg = model.cfg | |
| x = np.asarray(x, 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) | |
| # optional: select top clusters by total energy to keep as components | |
| 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: | |
| # indices of clusters to keep | |
| 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) | |
| # residual = x - sum_kept_components | |
| if components: | |
| sum_comp = np.zeros_like(x) | |
| for v in components.values(): | |
| sum_comp += v | |
| residual = x - sum_comp | |
| else: | |
| residual = x.copy() | |
| meta = dict( | |
| fs=cfg.fs, | |
| win_len=L, | |
| hop=hop, | |
| n_fft=n_fft, | |
| window_type=cfg.window_type, | |
| gaussian_sigma=cfg.gaussian_sigma, | |
| n_clusters=model.centroids.shape[0], | |
| used_clusters=used_clusters, | |
| max_clusters=max_clusters, | |
| feature_dim=model.centroids.shape[1], | |
| ) | |
| return DecompResult(components=components, residual=residual, meta=meta) | |