Quickstart¶
Batch Feature Extraction¶
One row in, one feature row out. The Rust engine executes without GIL contention.
import numpy as np
import kymora
rng = np.random.default_rng(0)
X = rng.standard_normal((10_000, 500)) # 10,000 series, 500 samples each
feats = kymora.extract_features(X) # (10_000, 33) float64
names = kymora.feature_names() # canonical column names
Input arrays must be float64 or float32, C-contiguous. Any other dtype raises TypeError (cast explicitly — kymora never upcasts silently); non-contiguous layouts raise ValueError unless contiguous="copy". See Numerics.
Multi-View Extraction¶
Generate multi-domain feature representations across differences, detrending, and normalizations:
# Compute features across original series, first differences, and z-normalization
feats_views = kymora.extract_features(
X,
views=["raw", "diff", "znorm"]
)
view_names = kymora.feature_names(views=["raw", "diff", "znorm"])
print(f"Extracted {len(view_names)} features across 3 views.")
Features that are mathematically invariant to a transform (e.g. standard deviation under mean shift) are automatically pruned.
Multichannel Sensor Streams¶
Extract features and cross-channel interaction dynamics from 3D arrays:
# (n_samples, n_channels, length)
X_mc = rng.standard_normal((100, 4, 1000))
# Extract per-channel features and cross-channel dynamics
df_mc = kymora.extract_features_mc_df(X_mc, cross=True)
print(df_mc.shape) # 100 rows x combined channel features
Real-Time Fleet Streaming¶
Stream thousands of live signals concurrently with incremental per-stream state updates:
n_streams = 1000
window_size = 200
# Fleet extractor maintains contiguous circular buffers for all streams
extractor = kymora.MultiStreamExtractor(n_streams, window_size)
# Ingest new readings from IoT fleet or market feed
new_tick = rng.standard_normal(n_streams)
is_ready = extractor.push_many(new_tick)
if is_ready:
# Fast 6-feature tier (mean, std, var, energy, RMS, crossings) —
# no sorting, no FFT
fast_matrix = extractor.compute(kind="fast")
Feature Extraction in Scikit-Learn¶
The in-package transformer turns a panel into a feature matrix inside any
pipeline (pip install "kymora[sklearn]"):
from kymora.sklearn import KymoraTransformer
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
X = rng.standard_normal((200, 128))
y = (X.sum(axis=1) > 0).astype(int)
pipe = Pipeline([
("features", KymoraTransformer(profile="minimal")),
("scaler", StandardScaler()),
("clf", LogisticRegression()),
])
pipe.fit(X, y)
Supervised Feature Selection in Scikit-Learn¶
Select statistically significant, non-redundant features using FDR control and correlation clustering:
from sklearn.pipeline import Pipeline
from sklearn.ensemble import HistGradientBoostingClassifier
# scikit-learn transformer
pipe = Pipeline([
("select", kymora.KymoraSelector(task="classification", fdr=0.05)),
("clf", HistGradientBoostingClassifier())
])
# Labels for the batch extracted above
y = (feats[:, 0] > feats[:, 0].mean()).astype(int)
# Fits FDR hypothesis tests and correlation clusters on X_feats, y
pipe.fit(feats, y)
predictions = pipe.predict(feats)
Hardware Auto-Tuning (Wisdom)¶
Benchmark your local architecture to configure the optimal execution backend:
# Microbenchmarks execution variants and caches the best configuration
profile = kymora.tune(shapes=[(1000, 500)], budget_s=5.0)
print(f"Optimal pool: {profile['best_config']['pool']}")
Pool selection is provisional
tune() records a spin/rayon recommendation, but the KYMORA_POOL
switch is not wired up yet (see Threading & Runtime Controls) —
scheduling is Rayon either way today.