Skip to content

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.