aeon

Files (1)

• SKILL.md

SKILL.md (first lines)

# aeon

## Overview

aeon provides a unified scikit-learn-compatible API for time series ML tasks: classification, regression, clustering, segmentation, annotation, similarity search, and transformation. It follows the same `fit(X, y)` / `predict(X)` pattern as scikit-learn, where `X` is a 3D NumPy array of shape `(n_instances, n_channels, n_timepoints)`. aeon curates state-of-the-art algorithms from the time series literature — ROCKET and its variants (MiniROCKET, MultiROCKET) for classification, k-means with DTW for clustering, CLASP for segmentation — and provides benchmarking tools for comparing algorithms across datasets. It is the community-maintained fork of sktime following the 2022 governance split.

## When to Use

- Classifying ECG, EEG, accelerometer, or sensor time series using state-of-the-art algorithms
- Regressing a scalar target from a time series input (e.g., predicting patient severity from vital sign waveforms)
- Clustering time series by shape similarity when class labels are unavailable
- Detecting change points or segmenting a continuous recording into homogeneous intervals
- Extracting fixed-length feature vectors from variable-length time series for downstream ML
- Benchmarking time series algorithms on the UCR/UEA archive with reproducible comparisons
- Use sktime when you need a larger ecosystem or existing code depends on its API; use tslearn for DTW-focused work

## Prerequisites

- **Python packages**: `aeon`, `numpy`, `scikit-learn`, `matplotlib`
- **Data format**: 3D NumPy array `(n_instances, n_channels, n_timepoints)` or 2D `(n_instances, n_timepoints)` for univariate
- **Optional**: `numba` (required for ROCKET, DTW — install via `pip install aeon[all_extras]`)

```bash
pip install aeon
pip install aeon[all_extras]  # includes numba, statsmodels for full algorithm support
```

## Quick Start

```python
import numpy as np
from aeon.classification.convolution_based import RocketClassifier
from aeon.datasets import load_unit_test

# Load a small benchmark dataset
X_train, y_train = load_unit_test(split="train")  # shape: (n, 1, timepoints)
X_test, y_test = load_unit_test(split="test")

print(f"Train: {X_train.shape}, classes: {np.unique(y_train)}")

clf = RocketClassifier(num_kernels=500, random_state=42)
clf.fit(X_train, y_train)
accuracy = clf.score(X_test, y_test)
print(f"ROCKET accuracy: {accuracy:.3f}")
```

## Core API

### Module 1: Time Series Classification

30+ classifiers spanning convolution, dictionary, distance, feature, interval, and shapelet families.

```python
import numpy as np
from aeon.datasets import load_unit_test
from aeon.classification.convolution_based import RocketClassifier, MiniRocketClassifier
from aeon.classification.distance_based import KNeighborsTimeSeriesClassifier
from aeon.classification.feature_based import Catch22Classifier
from sklearn.metrics import accuracy_score

X_train, y_train = load_unit_test(split="train")
X_test, y_test   = load_unit_test(split="test")

classifiers = {
    "ROCKET":    RocketClassifier(num_kernels=1000, random_state=42),
    "MiniROCKET": MiniRocketClassifier(random_state=42),
    "KNN-DTW":   KNeighborsTimeSeriesClassifier(n_neighbors=1, distance="dtw"),
    "Catch22":   Catch22Classifier(random_state=42),
}

for name, clf in classifiers.items():
    clf.fit(X_train, y_train)
    acc = accuracy_score(y_test, clf.predict(X_test))
    print(f"{name:15s}: {acc:.3f}")
```

```python
# Multivariate classification (multiple channels)
from aeon.classification.convolution_based import MultiRocketMultivariateClassifier

# Synthetic multivariate time series: 100 instances, 3 channels, 50 timepoints
np.random.seed(0)
X_mv_train = np.random.randn(100, 3, 50)
y_mv_train = (X_mv_train[:, 0, :].mean(axis=1) > 0).astype(str)
X_mv_test  = np.random.randn(30, 3, 50)
y_mv_test  = (X_mv_test[:, 0, :].mean(axis=1) > 0).astype(str)

clf_mv = MultiRocketMultivariateClassifier(random_state=42)
clf_mv.fit(X_mv_train, y_mv_train)
print(f"Multivariate accuracy: {clf_mv.score(X_mv_test, y_mv_test):.3f}")
```

### Module 2: Time Series Regression

Predict a continuous target from a time series input.

```python
import numpy as np
from aeon.regression.convolution_based import RocketRegressor
from aeon.regression.distance_based import KNeighborsTimeSeriesRegressor
from sklearn.metrics import mean_squared_error

# Synthetic regression: predict the mean of each series
np.random.seed(42)
X_train = np.random.randn(200, 1, 100)
y_train = X_train[:, 0, :].mean(axis=1) + np.random.randn(200) * 0.1
X_test  = np.random.randn(50, 1, 100)
y_test  = X_test[:, 0, :].mean(axis=1) + np.random.randn(50) * 0.1

reg = RocketRegressor(num_kernels=500, random_state=42)
reg.fit(X_train, y_train)
y_pred = reg.predict(X_test)
mse = mean_squared_error(y_test, y_pred)
print(f"ROCKET regressor MSE: {mse:.4f}")
```

### Module 3: Time Series Clustering

Group time series by shape similarity without class labels.

From FridrichMethod/awesome-skills, BSD-3-Clause.

More from FridrichMethod/awesome-skills